diff --git a/docs/architecture/distillation-semantic-handoff.md b/docs/architecture/distillation-semantic-handoff.md
new file mode 100644
index 00000000..d7862751
--- /dev/null
+++ b/docs/architecture/distillation-semantic-handoff.md
@@ -0,0 +1,191 @@
+---
+title: Distillation semantic handoff
+description: How the distiller became a true agentic step that writes facts DIRECTLY into cognitive memory through the memory write tool, removing the JSON-scrape-and-deserialize gate from the distillation result path so a trailing comma or a noisy launcher banner can no longer discard a whole batch (issue #2679 / #2658).
+last_updated: 2026-07-06
+owner: simard
+doc_type: concept
+related:
+  - ./episode-distillation.md
+  - ./cognitive-memory.md
+  - ./rpc-pattern.md
+  - ../reference/simard-memory-remember-cli.md
+  - ../reference/distill-write-boundary-gate.md
+  - ../reference/automatic-distillation-scheduler.md
+  - ../reference/telemetry-metrics.md
+  - ../howto/verify-the-distillation-semantic-handoff.md
+  - ../memory.md
+---
+
+# Distillation semantic handoff
+
+> Shipped in issue [#2679](https://github.com/rysweet/Simard/issues/2679)
+> (root cause shared with [#2658](https://github.com/rysweet/Simard/issues/2658)).
+> This is the successor to the JSON-file result path documented in
+> [Episode distillation](./episode-distillation.md): the batch of episodes,
+> the concept labels, the threshold gate, and the mark-everything rule are all
+> unchanged — **only the way distilled facts reach memory changed.**
+
+Episode distillation is a **many-to-few** pass: it reads a batch of recent
+episodes and produces a small number of durable semantic facts. Before #2679
+the distiller agent was told to *print* (later, *write to a file*) a
+`{ "facts": [...] }` envelope, and Simard then **scraped that text back out and
+hand-deserialized it** with `serde_json`. That deserialize was the single
+failure surface: one malformed token — a trailing comma, a stray log line, an
+ANSI escape from the copilot launcher banner — made the strict parse fail and
+**discarded the entire batch**. The parse-fail rate had climbed from 91% to
+100%.
+
+The fix does **not** make the parser more lenient. It **removes the parse
+entirely.** The distiller is now a real agentic step whose *writes are its
+output*: it calls the cognitive-memory write tool once per fact, and those
+writes land in the same store Simard reads from. There is no return document
+for Simard to deserialize, so the trailing-comma / noisy-stdout failure mode is
+**structurally impossible** — there is nothing left to fail.
+
+---
+
+## What changed in one picture
+
+**Before (#2281 → #2622, removed):**
+
+```
+distiller agent  ──writes──▶  facts.json  ──Simard reads & serde_json::from_str──▶  DistillOutput
+                                              │
+                                              └─ trailing comma / noisy bytes → PARSE FAIL → whole batch discarded
+```
+
+**After (#2679):**
+
+```
+distiller agent ──`simard memory remember` (once per fact)──▶ memory IPC socket ──▶ write-boundary gate ──▶ cognitive memory
+                                                                                        (ground · score · quarantine · dedup)
+        (no return payload — the agent's writes ARE the output; nothing for Simard to parse)
+```
+
+Simard's role shrinks to: **prepare the batch, guarantee a live write endpoint,
+run the agent, and count how many facts it successfully committed.** No text is
+extracted. No JSON is deserialized. `DistilledFact`, `DistillOutput`, the
+balanced-object scanner, and every `serde_json::from_str` on agent output are
+gone from the result path.
+
+---
+
+## The semantic handoff, step by step
+
+1. **Batch selection (unchanged).** `distill_recent_episodes_with_runner`
+   pulls up to `DISTILL_BATCH_SIZE` (50) undistilled episodes. If fewer than
+   `DISTILL_MIN_EPISODES` (20) are available, the pass is skipped entirely — no
+   agent, no writes, no markers. See
+   [Episode distillation → threshold gate](./episode-distillation.md#threshold-gate).
+
+2. **Live-endpoint guarantee (new — D4 invariant).** Before the agentic step
+   runs, the scheduler ensures a reachable cognitive-memory **write** endpoint:
+   the OODA daemon's memory IPC socket (`<state_root>/memory.sock`, resolved by
+   `socket_path_for`). The subprocess runner threads that socket path to the
+   agent through the `SIMARD_MEMORY_SOCKET` environment variable, plus an
+   opaque `distill_pass_id` used only to tag and count this pass's writes. If no
+   endpoint can be guaranteed, the pass is **skipped gracefully** (`Ok(None)`)
+   exactly like an unavailable recipe runner — distillation never blocks the
+   OODA cycle, and it never falls back to stdout scraping.
+
+3. **Agentic write (new).** The `distill-episodes` recipe no longer asks the
+   agent to emit a JSON envelope. It instructs the agent to call
+   [`simard memory remember`](../reference/simard-memory-remember-cli.md) **once
+   per fact** (and `simard memory remember-procedure` once per recurring
+   procedure). Each call is one process, one fact — scalar flags only, no
+   document. The CLI routes through the memory IPC client to the daemon. The
+   agent's file-reading tool still reads the episode batch from `episodes_path`;
+   only the *output* channel changed.
+
+4. **Write-boundary gate (moved — D2).** Every fact passes through **one
+   authoritative gate on the server side** of the IPC boundary: grounding by
+   confirming the fact's supplied `source_episode_ids` resolve to real episode
+   nodes **in the store** (a store-existence check — the server holds no
+   in-memory batch, and a fact is grounded if **at least one** supplied id
+   resolves), ISAO-style reliability scoring, confidence clamp + minimum
+   threshold, low-reliability **quarantine**, and identity dedup, before
+   `store_fact_with_provenance` persists it with one `DERIVES_FROM` edge per
+   supplied source episode. The gate now lives at the write boundary because
+   direct agent writes bypass the old post-parse location. The client is never
+   trusted to pre-score; the server is the sole decision point. See
+   [Distill write-boundary gate](../reference/distill-write-boundary-gate.md).
+
+5. **Marking (unchanged).** On a clean agent run, every input episode is marked
+   distilled — including those the agent chose to skip — so the batch is never
+   re-fed. If the agentic step fails as a whole (non-zero exit), no markers are
+   set and the batch retries next pass, preserving the original retry-safety
+   invariant.
+
+6. **Reporting (new source).** Success is "the agentic commit completed." The
+   fact count in `DistillReport` and the `simard.distill.facts` metric come from
+   the **write ledger** — the number of facts the gate actually accepted for
+   this `distill_pass_id` — not from the length of a parsed array. Quarantined
+   candidates are counted separately, exactly as before.
+
+---
+
+## Why removal, not tolerance
+
+The facts are **only ever consumed by another agent** — the cognitive-memory
+brain that reads them back during preparation. Marshalling them through a strict
+JSON envelope that Simard hand-parses was pure ceremony sitting between two
+agents. It added no value and was the entire failure surface. A lenient parser
+would have kept the ceremony and merely hidden some failures; representing each
+fact as a **tool call** removes the document, and with it the class of failure.
+
+This is a **semantic** agent-to-agent handoff: the meaning (a fact, a concept, a
+provenance link) is transmitted as a memory operation, not as a serialized blob
+that must survive a lossy stdout channel intact.
+
+---
+
+## The `parse_fail` failure class is gone
+
+`DistillFailureClass::ParseFailure`, the `ATTR_RESULT="parse_fail"` telemetry
+attribute, the `distill_parse_success_rate` denominator, and the env-gated
+raw-capture-on-parse-failure diagnostic are all **removed**. No code path can
+emit `parse_fail` because there is no parse. The surviving failure classes are
+the structural ones that never involved parsing (spawn failure, recipe-reported
+terminal failure). Success telemetry (`simard.distill.runs` `result=ok`,
+`simard.distill.facts`, `simard.distill.procedures`,
+`simard.distill.episodes_marked`) is preserved. See
+[Telemetry metrics](../reference/telemetry-metrics.md#distillation-simarddistill).
+
+> **Migration note for dashboards & alerts.** Any panel or alert keyed on
+> `simard.distill.runs{result="parse_fail"}` or `distill_parse_success_rate`
+> will read zero / empty after #2679 — those series no longer exist. Track
+> `simard.distill.runs{result="ok"}` and `simard.distill.facts` instead.
+
+---
+
+## Back-compatibility for test & stub runners
+
+The `DistillRecipeRunner` trait change is **additive with defaults**. Stub and
+test runners that implement the in-process `run` / `run_all` path still compile
+and pass unmodified: they perform their (mock) memory writes in process rather
+than shelling out, and the result path counts the ledger the same way. Only
+`RecipeRunnerSubprocess` overrides the new behaviour to inject
+`SIMARD_MEMORY_SOCKET` + `distill_pass_id` and treat exit-0 as success with no
+stdout consumption.
+
+---
+
+## Boundaries — what this change does *not* touch
+
+- **The batch, labels, threshold, and marking rules** are unchanged; see
+  [Episode distillation](./episode-distillation.md).
+- **The shared `recipe_output` extract helpers** (`extract_json_payload`,
+  `balanced_objects`, `extract_verdict`) are **not deleted** — other,
+  out-of-scope agent→agent stdout-scrape sites (merge-readiness judge, progress
+  reviewer, recipe-brain) still use them. Those are filed as **follow-on
+  candidates** for the same semantic-handoff treatment
+  ([#2715](https://github.com/rysweet/Simard/issues/2715) — OODA brain
+  decide/orient verdict; [#2716](https://github.com/rysweet/Simard/issues/2716) —
+  merge-readiness judge verdict); migrating them is out of scope here.
+- **No lenient/tolerant JSON parsing** is introduced anywhere as a substitute.
+
+See also: [Distill write-boundary gate](../reference/distill-write-boundary-gate.md)
+for the gate + IPC schema, the
+[`simard memory remember` CLI reference](../reference/simard-memory-remember-cli.md)
+for the write tool, and the how-to
+[Verify the distillation semantic handoff](../howto/verify-the-distillation-semantic-handoff.md).
diff --git a/docs/architecture/episode-distillation.md b/docs/architecture/episode-distillation.md
index 0fc2127d..302ba6e1 100644
--- a/docs/architecture/episode-distillation.md
+++ b/docs/architecture/episode-distillation.md
@@ -5,6 +5,9 @@ last_updated: 2026-06-14
 owner: simard
 doc_type: concept
 related:
+  - ./distillation-semantic-handoff.md
+  - ../reference/simard-memory-remember-cli.md
+  - ../reference/distill-write-boundary-gate.md
   - ./cognitive-memory.md
   - ./episode-ingestion-policy.md
   - ../reference/cognitive-memory-preparation-filters.md
@@ -23,6 +26,22 @@ related:
 > as PR-B (episode distillation). Builds on PR-A (preparation filters)
 > and feeds PR-C (episodic recall) with a higher-quality semantic store.
 
+> **Superseded result path (#2679).** Everything below about *how distilled
+> facts reach memory* — the agent writing a `{ "facts": [...] }` envelope to a
+> `facts_output_path` file, Simard reading that file and deserializing it with
+> `serde_json`, the `ParseFailure` / `parse_fail` class, and the
+> raw-capture-on-parse-failure diagnostic — has been **replaced** by a semantic
+> agent-to-agent handoff. The distiller now writes each fact **directly** into
+> cognitive memory via [`simard memory remember`](../reference/simard-memory-remember-cli.md);
+> there is no returned document and **no parse**, so a trailing comma or a noisy
+> launcher banner can no longer discard a batch. The batch selection, concept
+> labels, threshold gate, and mark-everything rule described below are
+> unchanged. See
+> [Distillation semantic handoff](./distillation-semantic-handoff.md) for the
+> current result path and
+> [Distill write-boundary gate](../reference/distill-write-boundary-gate.md) for
+> where the reliability/quarantine/dedup gate now lives.
+
 Episode distillation is the periodic process that scans recent
 **episodic** memory and extracts **semantic facts** from it using a
 deterministic LLM recipe. It is the missing half of memory
diff --git a/docs/howto/verify-the-distillation-semantic-handoff.md b/docs/howto/verify-the-distillation-semantic-handoff.md
new file mode 100644
index 00000000..fe2d78f9
--- /dev/null
+++ b/docs/howto/verify-the-distillation-semantic-handoff.md
@@ -0,0 +1,136 @@
+---
+title: Verify the distillation semantic handoff
+description: Step-by-step how-to for confirming that episode distillation writes facts DIRECTLY into cognitive memory via `simard memory remember` (issue #2679) — running a pass, watching the write ledger, using `simard memory stats` to see the fact count climb, and proving that a noisy / trailing-comma agent output no longer fails because nothing is parsed.
+last_updated: 2026-07-06
+review_schedule: as-needed
+owner: simard
+doc_type: howto
+related:
+  - ../architecture/distillation-semantic-handoff.md
+  - ../reference/simard-memory-remember-cli.md
+  - ../reference/distill-write-boundary-gate.md
+  - ../reference/simard-memory-cli.md
+  - ../architecture/episode-distillation.md
+---
+
+# Verify the distillation semantic handoff
+
+Use this how-to to confirm that distillation is reaching cognitive memory the
+**new** way (issue [#2679](https://github.com/rysweet/Simard/issues/2679)): the
+distiller agent calls `simard memory remember` once per fact, and Simard never
+parses a returned document. The property you are verifying is that facts flow
+**agent → memory** semantically, and that malformed agent text can no longer
+discard a batch — because there is nothing to parse.
+
+## Before you start
+
+- The OODA daemon must be **running** (writes require a live memory socket).
+- Confirm the daemon is up and serving the memory socket:
+
+  ```bash
+  simard memory stats            # banner should read "via daemon socket"
+  ```
+
+## 1. Snapshot the current fact count
+
+```bash
+simard memory stats --json | tee /tmp/before.json
+```
+
+Note the `semantic` (facts) count. This is your baseline.
+
+## 2. Trigger a distillation pass
+
+Distillation fires automatically once the undistilled backlog crosses threshold
+(see [Automatic distillation scheduler](../reference/automatic-distillation-scheduler.md)),
+or you can let the daemon reach a `__memory__` cycle. Watch the daemon log for
+the pass:
+
+```text
+[simard] distill scheduler: Threshold trigger fired (undistilled≈37, cycles_since_last=6)
+[simard] distill: 37 episodes pulled (batch size 50, min 20)
+```
+
+During the pass you should see per-fact write lines from the agentic step, e.g.:
+
+```text
+[simard] memory remember: stored concept=lesson-learned confidence=0.90 node_id=sem_41
+[simard] memory remember: stored concept=bug-pattern confidence=0.90 node_id=sem_42
+[simard] memory remember: quarantined concept=pr-pattern confidence=0.40 (below gate)
+```
+
+Each line is one `simard memory remember` invocation — one process, one fact.
+There is **no** `{ "facts": [...] }` envelope in the log and **no** parse step.
+
+## 3. Confirm the fact count climbed
+
+```bash
+simard memory stats --json | tee /tmp/after.json
+```
+
+The `semantic` count should be higher than your baseline by the number of
+**stored** (non-quarantined) facts. Quarantined candidates are counted in the
+pass report but are intentionally not persisted — that is the write-boundary
+gate protecting memory integrity, not a failure.
+
+## 4. Check the telemetry
+
+```bash
+grep -E 'simard\.distill\.(runs|facts)' ~/.simard/metrics.jsonl | tail
+```
+
+You should see `simard.distill.runs{result="ok"}` and a `simard.distill.facts`
+count equal to the stored-fact tally from step 3.
+
+> **You will NOT see `result="parse_fail"`.** That series was removed in #2679 —
+> there is no parse to fail. If a dashboard still queries it, it will read empty;
+> switch it to `result="ok"` / `simard.distill.facts`. See
+> [write-boundary gate → telemetry](../reference/distill-write-boundary-gate.md#telemetry-changes).
+
+## 5. Prove noisy output no longer breaks the pipeline
+
+This is the core #2679 property. In a test/dev environment, point distillation
+at a stub runner whose agent step emits **deliberately hostile** text on
+stdout — ANSI escapes, tracing log lines, a copilot launch banner, and a
+trailing comma — while performing its memory writes normally. The pass must
+**succeed** and the facts must reach memory, because the stdout is never read as
+the result.
+
+The shipped regression suite encodes exactly this
+(`src/memory_consolidation/distillation.rs` tests): a runner returns
+launcher-banner + ANSI + tracing noise **and** a trailing comma, the agentic
+step performs mock `remember` writes, and the assertions are:
+
+1. the pass returns `Ok` (no error),
+2. the mock memory received the expected facts, and
+3. **no `parse_fail`** is recorded (the metric/attribute does not exist).
+
+If you are writing your own check, assert the same three properties. The point
+is not that the parser tolerates the bad bytes — it is that **there is no parser
+on this path**.
+
+## 6. Automated process-boundary proof (no daemon needed)
+
+Steps 1–5 verify a running daemon. To prove the same handoff hermetically —
+the **real `simard` binary** committing through a **live memory socket** with no
+daemon and no fixtures — run the process-boundary integration suite:
+
+```bash
+cargo test --locked --test bin_simard_memory_remember_cli
+```
+
+It spawns a real IPC server over an in-memory store, then invokes
+`simard memory remember` / `remember-procedure` as separate processes and pins
+the exit-code contract against the gate: a grounded fact stores (exit `0`) and
+is retrievable, an ungrounded fact is quarantined (exit `4`), a missing daemon
+exits `3` (no un-gated fallback), and a malformed invocation exits `2`. This is
+the automated stand-in for steps 2–3 when you do not have a daemon handy.
+
+## Troubleshooting
+
+| Symptom | Likely cause | Action |
+|---------|--------------|--------|
+| `remember` exits `3` (no endpoint) during a pass | Daemon socket absent; pass was skipped, not failed | Confirm the daemon is up (`simard memory stats`); the batch retries next cycle. |
+| Fact count did not climb, log shows all `quarantined` | Facts scored below `DISTILL_RELIABILITY_THRESHOLD` | Expected gate behaviour; inspect grounding/quality of the source episodes. See [write-boundary gate](../reference/distill-write-boundary-gate.md#the-single-authoritative-gate). |
+| Pass logged a spawn/terminal failure, no markers set | Structural recipe failure (not a parse) | Batch stays retry-eligible; check `recipe-runner-rs` availability and the agent binary. |
+| Looking for a `parse_fail` metric | Removed in #2679 | Use `simard.distill.runs{result="ok"}` and `simard.distill.facts`. |
diff --git a/docs/reference/distill-write-boundary-gate.md b/docs/reference/distill-write-boundary-gate.md
new file mode 100644
index 00000000..70d33849
--- /dev/null
+++ b/docs/reference/distill-write-boundary-gate.md
@@ -0,0 +1,259 @@
+---
+title: Distill write-boundary gate & memory-IPC gated write
+description: Reference for the single authoritative write-boundary gate that scores, quarantines, and dedups every distilled fact server-side (issue #2679 / #2433), the additive memory-IPC StoreFactGated / StoreProcedureProvenance requests and FactWrite response, the shared fact_reliability scorer, the removal of the parse_fail telemetry class, and the daemon socket hardening (0600/0700 + MAX_FRAME).
+last_updated: 2026-07-06
+owner: simard
+doc_type: reference
+related:
+  - ../architecture/distillation-semantic-handoff.md
+  - ./simard-memory-remember-cli.md
+  - ./rpc-wire-protocol.md
+  - ./cognitive-memory-provenance.md
+  - ./telemetry-metrics.md
+  - ./trustworthy-confidence-api.md
+  - ../architecture/rpc-pattern.md
+  - ../memory.md
+---
+
+# Distill write-boundary gate & memory-IPC gated write
+
+> Shipped in issue [#2679](https://github.com/rysweet/Simard/issues/2679).
+> Homes the ISAO reliability gate first landed in
+> [#2433](https://github.com/rysweet/Simard/issues/2433) at the **write
+> boundary** so it still runs when facts arrive as direct agent writes instead
+> of a parsed batch.
+
+When distillation stopped returning a parseable document
+([distillation semantic handoff](../architecture/distillation-semantic-handoff.md)),
+the reliability/quarantine/dedup logic that used to run in Simard *after the
+parse* had nowhere to sit. This reference documents where it moved, the IPC
+schema that carries a gated write, the shared scorer, and the telemetry and
+socket-hardening consequences.
+
+---
+
+## The single authoritative gate
+
+Every distilled fact is decided in **exactly one place**: the memory IPC
+server's handler for a gated-write request. There is no client-side gate and no
+un-gated write variant reachable by the distiller. The handler applies, in
+order:
+
+1. **Input validation** — every field is opaque data; a required field that is
+   empty (`concept`, `content`) or a field over its length cap is rejected
+   (quarantined, nothing stored) rather than truncated silently. `MAX_FRAME`
+   already bounds the whole request.
+2. **Grounding (store-existence check)** — confirm the fact's supplied
+   `source_episode_ids` resolve to real episode nodes **in the store**. The
+   server holds no in-memory batch, so grounding is an existence lookup, not a
+   batch scan: the fact is grounded if **at least one** supplied id resolves.
+   An ungrounded fact (no id resolves) scores low and is quarantined — never
+   stored blind. The write records provenance to each resolved id.
+3. **Reliability scoring** — `fact_reliability::score_fact_reliability` computes a
+   confidence in `[0.0, 1.0]` (already clamped into range by the scorer) from the
+   fact and its resolved grounding. The client cannot supply this; any
+   client-provided `confidence` hint is ignored. There is **no** confidence floor
+   — an ungrounded or empty fact keeps its genuinely low score so the threshold
+   can quarantine it. (Fail-closed: an unscoreable input scores low, never stored
+   blind.)
+4. **Threshold quarantine** — if the score is below
+   `DISTILL_RELIABILITY_THRESHOLD`, the fact is **quarantined** (counted, not
+   stored) so a low-reliability candidate can never corrupt past experience.
+5. **Identity dedup** — a weaker-or-equal new fact never clobbers a
+   higher-confidence existing fact of the **same identity** (concept + content).
+   Distinct lessons that merely share a label still accumulate.
+6. **Persist** — surviving facts are written with
+   `store_fact_with_provenance` (computed confidence, **one `DERIVES_FROM` edge
+   per supplied `source_episode_id`**, and a scalar `source_id` of
+   `distill:{ids[0]}` — the first/primary id, with the full provenance set
+   carried by the edges). When exactly one id is supplied this reduces to the
+   familiar `distill:{source_episode_id}` form.
+7. **Pass ledger** — the disposition (stored / quarantined) is recorded against
+   the request's opaque `pass_id` so the scheduler can report accurate counts
+   without parsing anything.
+
+Because the gate is server-side, the same guarantees hold whether a fact arrives
+from the distiller, a manual `simard memory remember`, or any future agentic
+writer.
+
+---
+
+## `fact_reliability` — the shared scorer
+
+`src/fact_reliability.rs` is a small, mostly-pure module holding the scorer, the
+threshold constant, the concept-label helpers, and — since the #2679 refactor —
+the shared **write-boundary gate orchestration** itself
+(`commit_gated_fact`: score → threshold → identity-dedup → persist). It exists so
+the **stub in-process loop** (used by test runners) and the **IPC handler** reach
+the **same disposition** for the same fact — one implementation, two call sites.
+Each seam resolves only what genuinely differs per boundary (grounding —
+batch-membership vs. store-existence) and then defers the score/threshold/dedup/
+persist decision to the one shared function, so the two seams can never drift.
+Consolidating the gate here also shrinks the `src/memory_consolidation` fork,
+keeping engine-shaped logic consolidated per the G2 architecture rule.
+
+The scorer is a **pure function of one fact plus its resolved grounding** — it
+takes **no batch argument**. Grounding is the dominant, *necessary* signal (a
+grounded fact already clears the threshold; an ungrounded one never can), so
+the store/quarantine **decision is fully determined per-fact**. The legacy
+in-process scorer additionally awarded a small same-concept **corroboration**
+bonus computed over the whole batch; that term is **deliberately excluded** from
+the shared scorer because (a) a per-fact IPC write has no sibling batch to
+inspect, and (b) it is **disposition-neutral** — corroboration was awarded only
+to already-grounded facts and merely nudged an already-storable confidence
+upward (e.g. `0.9 → 1.0`), never flipping `store ↔ quarantine`. Dropping it is
+exactly what lets the stub and the IPC handler agree on every decision.
+
+| Symbol | Meaning |
+|--------|---------|
+| `fact_reliability::score_fact_reliability(concept: &str, content: &str, grounded: bool) -> f64` | Confidence in `[0.0, 1.0]` from the fact's concept/content and whether its provenance resolved. Deterministic; fail-closed (ungrounded / empty → low → quarantined). No batch argument. |
+| `fact_reliability::fact_passes_gate(concept, content, grounded) -> bool` | Thin predicate: `score >= RELIABILITY_THRESHOLD`. The shared store/quarantine decision. |
+| `fact_reliability::commit_gated_fact(memory, concept, content, grounded, source_id, tags, source_episode_ids) -> SimardResult<FactGateDecision>` | The shared gate orchestration both seams call: score → threshold → identity-dedup → `store_fact_with_provenance`. Grounding is resolved by the caller; the returned `FactGateDecision` is `Stored { confidence, node_id }` or `Quarantined { confidence }` (a `confidence >= RELIABILITY_THRESHOLD` quarantine is a dedup skip, below is a low-reliability block). |
+| `fact_reliability::RELIABILITY_THRESHOLD` (re-exported as `distillation::DISTILL_RELIABILITY_THRESHOLD`) | Minimum confidence to store rather than quarantine (`0.5`). |
+| `fact_reliability::canonical_concept(label) -> Option<&'static str>` | Canonicalises / validates a concept label. |
+
+> **G2 / D3 note.** #2679 homes the gate at the IPC handler that fronts
+> `amplihack-memory-lib`; it does **not** add a new memory-engine primitive, so
+> **no `amplihack-memory` pin bump is required** for this change. If a future
+> revision pushes the gate *into* the library as a first-class gated-write API,
+> that is where the pin bump would happen — not in `src/memory_consolidation`.
+
+---
+
+## Memory-IPC schema (additive)
+
+The write is carried by **new, additive** request variants on `MemoryRequest`
+and one new response variant on `MemoryResponse`. Every pre-existing variant
+(`StoreFact`, `StoreProcedure`, `GetStatistics`, …) is untouched, so existing
+clients and the `CognitiveMemoryOps` trait stay byte-compatible.
+
+### Request variants
+
+```jsonc
+// Gated single-fact write (backs `simard memory remember`).
+{ "op": "store_fact_gated",
+  "concept": "bug-pattern",
+  "content": "recipe-runner-rs E2BIG when a 50-episode batch is inlined on argv",
+  "source_episode_ids": ["ep_A", "ep_B"],
+  "pass_id": "distill-2026-07-06T12:00:00Z-7f3a" }
+
+// Procedure write with provenance (backs `simard memory remember-procedure`).
+{ "op": "store_procedure_provenance",
+  "name": "ci-fix:auto",
+  "steps": ["reproduce locally", "bisect", "apply minimal fix"],
+  "prerequisites": [],
+  "source_episode_ids": ["ep_C", "ep_D"],
+  "pass_id": "distill-2026-07-06T12:00:00Z-7f3a" }
+```
+
+Note there is **no `confidence` field** on the request — scoring is the server's
+job.
+
+### Response variant
+
+```jsonc
+// Result of a gated write. `disposition` is "stored" or "quarantined";
+// both are successful outcomes.
+{ "ok": "fact_write",
+  "value": { "disposition": "stored",
+             "confidence": 0.90,
+             "node_id": "fact_01H...",   // present when stored
+             "derives_from": 2 } }
+```
+
+The existing `{ "ok": "error", "value": "<msg>" }` variant still carries backend
+failures (which map to CLI exit `4`).
+
+### Client wrappers
+
+`RemoteCognitiveMemory` gains **inherent** (non-trait) methods
+`remember_fact_gated(..)` and `remember_procedure_provenance(..)` that build the
+new requests and interpret the `FactWrite` response. They are inherent, not
+`CognitiveMemoryOps` trait methods, so the trait — and every existing impl,
+including `SharedMemory` and the read-only clients — stays exactly as it was.
+
+---
+
+## Input validation & framing
+
+The IPC handler treats every field as **opaque data** and validates at the
+boundary:
+
+- **Length caps** on `concept`, `content`, `name`, each `step`, and each
+  `source_episode_id`. Over-long fields are rejected, not truncated silently.
+- **Empty-field rejection** for required fields (`concept`, `content`, `name`,
+  ≥1 `step`).
+- **`MAX_FRAME` cap** in `read_frame` (introduced by #2679 — `read_frame` was
+  previously uncapped): a length prefix above the cap is rejected before
+  allocation, bounding a single request's memory (DOS-1). This applies to *all*
+  IPC traffic, not just gated writes.
+- Fact bodies are **never logged**; only counts, concepts, and dispositions
+  appear in logs/metrics.
+
+---
+
+## Daemon socket hardening (AUTHZ-3 / DOS-1)
+
+The memory socket is now created with restrictive permissions:
+
+- The socket file is `0600` (owner read/write only).
+- Its parent directory is `0700`.
+- `read_frame` gains a `MAX_FRAME` ceiling (new in #2679; it was previously
+  uncapped) so a malformed or hostile length prefix cannot force a giant
+  allocation.
+
+These apply to the whole memory-IPC surface; the gated-write path inherits them.
+
+---
+
+## Telemetry changes
+
+The parse-based failure telemetry is **removed** because the parse is gone:
+
+| Removed | Replacement |
+|---------|-------------|
+| `simard.distill.runs{result="parse_fail"}` | — (unreachable; only `result="ok"` and structural failure classes remain) |
+| `distill_parse_success_rate` | — (no parse to succeed/fail) |
+| raw-capture-on-parse-failure diagnostic | — (nothing to capture) |
+
+Preserved / added:
+
+| Metric | Meaning |
+|--------|---------|
+| `simard.distill.runs{result="ok"}` | A distillation pass whose agentic commit completed. |
+| `simard.distill.facts` | Facts **accepted by the gate** for the pass — sourced from the write ledger keyed by `pass_id`, not a parsed array length. |
+| `simard.distill.procedures` | Procedures written for the pass. |
+| `simard.distill.episodes_marked` | Episodes marked distilled after the pass. |
+| distill write ledger (per `pass_id`) | Integer counts of stored vs quarantined writes; the authoritative source for the report. |
+
+See [Telemetry metrics → distillation](./telemetry-metrics.md#distillation-simarddistill).
+
+---
+
+## Failure classes after #2679
+
+| Class | Reachable? | Notes |
+|-------|-----------|-------|
+| `ParseFailure` / `parse_fail` | **No — removed** | There is no parse. |
+| spawn failure | Yes | recipe-runner-rs could not be launched. |
+| recipe terminal failure | Yes | non-zero exit from the agentic step. |
+| no write endpoint | Yes (skips pass) | socket absent → `Ok(None)`, retried next cycle. |
+
+Structural failures leave the batch **unmarked** and retry next pass, exactly as
+before.
+
+---
+
+## Follow-on candidates (filed, out of scope here)
+
+The same "agents marshal meaning through scraped stdout" anti-pattern exists at
+other sites. #2679 files follow-on issues to migrate them to a semantic handoff,
+but does **not** change them:
+
+- `extract_verdict` callers — merge-readiness / recipe-merge judge verdict
+  ([#2716](https://github.com/rysweet/Simard/issues/2716)).
+- Remaining `extract_json_payload` / `balanced_objects` callers — the OODA brain
+  decide/orient verdict in `recipe-brain`
+  ([#2715](https://github.com/rysweet/Simard/issues/2715)).
+- A possible `amplihack-memory-lib` gated-write primitive (R2) to eventually
+  home the gate inside the library rather than the Simard-side IPC handler.
diff --git a/docs/reference/simard-memory-remember-cli.md b/docs/reference/simard-memory-remember-cli.md
new file mode 100644
index 00000000..cce5778f
--- /dev/null
+++ b/docs/reference/simard-memory-remember-cli.md
@@ -0,0 +1,217 @@
+---
+title: Memory write CLI (`simard memory remember`)
+description: Operator and agent reference for `simard memory remember` and `simard memory remember-procedure` — the per-record cognitive-memory WRITE commands the distiller agent calls (one process = one fact) so distilled knowledge reaches memory as tool calls instead of a scraped JSON envelope (issue #2679).
+last_updated: 2026-07-06
+owner: simard
+doc_type: reference
+related:
+  - ./simard-memory-cli.md
+  - ./distill-write-boundary-gate.md
+  - ./cognitive-memory-provenance.md
+  - ./state-root-resolution.md
+  - ../architecture/distillation-semantic-handoff.md
+  - ../architecture/cognitive-memory-library-adapter.md
+  - ../memory.md
+---
+
+# Memory write CLI (`simard memory remember`)
+
+> Shipped in issue [#2679](https://github.com/rysweet/Simard/issues/2679).
+> This is the **write** companion to the read-only
+> [`simard memory stats` / `dump`](./simard-memory-cli.md) commands and the
+> guarded [`simard memory import`](./simard-memory-cli.md#simard-memory-import)
+> restore path.
+
+`simard memory remember` writes **one** semantic fact into Simard's cognitive
+memory. `simard memory remember-procedure` writes **one** procedure. They are
+the agent-facing tool the distiller calls during the
+[distillation semantic handoff](../architecture/distillation-semantic-handoff.md):
+instead of printing a `{ "facts": [...] }` envelope for Simard to scrape and
+deserialize, the distiller agent calls `remember` once per fact. The write **is**
+the output — there is no return document to parse, so a trailing comma or a
+noisy launcher banner can no longer discard a batch.
+
+Both commands are **single-record by design**: one process = one fact (or one
+procedure). There is deliberately no batch/array form and no JSON-body form —
+that would reintroduce the parse this feature removed. Facts are passed as
+**scalar flags** only.
+
+---
+
+## Why single-record, scalar-flag
+
+The whole point of #2679 is that **no Simard-side document is ever
+deserialized**. A `remember --concept ... --content ...` invocation carries its
+fields as argv scalars that the CLI packs straight into a typed IPC request; the
+daemon reads typed fields, never free text it must re-parse. Emitting N facts is
+N calls. This keeps the failure surface at zero: there is no envelope, no array,
+no trailing comma to get wrong.
+
+---
+
+## `simard memory remember`
+
+Write a single semantic fact.
+
+```text
+Usage: simard memory remember
+         --concept <pr-pattern|bug-pattern|lesson-learned|...>
+         --content <TEXT>
+         [--source-episode-id <ID> ...]
+         [--confidence <0..1>]
+         [--tags <a,b,c>]
+         [--pass-id <OPAQUE>]
+         [state-root]
+```
+
+| Flag | Required | Meaning |
+|------|----------|---------|
+| `--concept <LABEL>` | yes | Concept label for the fact. The distiller uses `pr-pattern`, `bug-pattern`, or `lesson-learned`; other callers may use any non-empty label. |
+| `--content <TEXT>` | yes | The fact body — a short, declarative sentence. Stored verbatim. Length-capped at the IPC handler (see [write-boundary gate](./distill-write-boundary-gate.md#input-validation-framing)). |
+| `--source-episode-id <ID>` | no (repeatable) | `node_id` of a source episode this fact derives from; repeat for several. The daemon writes **one `DERIVES_FROM` edge per id**, grounds the fact if **at least one** id resolves to a real episode node in the store, and sets the scalar `source_id` to `distill:{first id}`. |
+| `--confidence <0..1>` | no | A confidence **hint** only. The server IGNORES it and re-derives the stored confidence from the write-boundary gate; it is accepted (and range-parsed) purely so a caller may pass one without erroring. |
+| `--tags <a,b,c>` | no | Comma-separated tags stored with the fact. Empty entries are dropped. |
+| `--pass-id <OPAQUE>` | no | Opaque pass identifier used to attribute this write to a distillation pass in the daemon's write ledger, so the pass can count how many facts the gate accepted. Injected by the runner; irrelevant for manual use. |
+| `state-root` (positional) | no | Explicit state root; the socket resolves to `<state_root>/memory.sock`. Omit to fall back to `$SIMARD_STATE_ROOT`, then `$HOME/.simard` (see [State-root resolution](./state-root-resolution.md)). Independently, a **non-empty `SIMARD_MEMORY_SOCKET` overrides the socket path verbatim**, bypassing state-root joining entirely. |
+
+`--confidence` is a hint the caller cannot use to self-rate: confidence is
+computed **server-side** by the [write-boundary gate](./distill-write-boundary-gate.md)
+from provenance grounding, content, and concept — the client is not trusted.
+
+### Behaviour
+
+1. Parses the scalar flags. A missing `--concept`/`--content` or an unparseable
+   flag is a **usage error (exit 2)** — nothing is sent.
+2. Resolves the memory socket via `socket_path_for(state_root)` — a non-empty
+   `SIMARD_MEMORY_SOCKET` is returned **verbatim** as the socket path, otherwise
+   the socket is `<state_root>/memory.sock`.
+3. Connects to the running daemon over the memory IPC socket and sends one
+   `StoreFactGated` request. There is deliberately **no** direct-open fallback: a
+   direct open would bypass the server-side gate, so if no daemon is reachable the
+   tool exits **3** rather than writing un-gated.
+4. The daemon applies the write-boundary gate (ground → score → quarantine →
+   dedup → persist) and reports its disposition. A **stored** fact exits `0`; a
+   **quarantined** fact exits `4` (a normal, expected gate decision, surfaced so a
+   mis-grounding agent is diagnosable, not an error the pass should retry).
+5. Prints a one-line human result and exits.
+
+### Exit codes
+
+| Code | Meaning |
+|------|---------|
+| `0` | Fact **stored** — it cleared the gate and was persisted with provenance. |
+| `2` | Usage error — missing/empty `--concept` or `--content`, a non-numeric `--confidence`, or an unknown flag. Nothing was sent. |
+| `3` | No gated write path — the daemon socket is absent / the connection failed, **or** the gated write itself errored. The fact was **not** stored; the caller (or scheduler) treats the pass as skipped. There is no un-gated fallback. |
+| `4` | The daemon **quarantined** the fact (ungrounded, empty content, or below the reliability threshold). Nothing was stored. |
+
+Exit codes are stable so the recipe/agent and any wrapping tooling can branch on
+outcome without scraping the message text.
+
+### Examples
+
+Write one lesson-learned fact with provenance:
+
+```bash
+simard memory remember \
+  --concept lesson-learned \
+  --content "CARGO_TARGET_DIR must point off the OOM-prone tmpfs for CI linker steps" \
+  --source-episode-id ep_01H9Z...
+```
+
+Write a fact derived from two episodes, tagged to a distillation pass:
+
+```bash
+simard memory remember \
+  --concept bug-pattern \
+  --content "recipe-runner-rs E2BIG when a 50-episode batch is inlined on argv" \
+  --source-episode-id ep_A --source-episode-id ep_B \
+  --pass-id distill-2026-07-06T12:00:00Z-7f3a
+```
+
+Human output (fact stored — exit 0):
+
+```text
+[simard] memory remember: stored concept=bug-pattern confidence=0.90 node_id=sem_42
+```
+
+Human output (fact quarantined by the gate — exit 4):
+
+```text
+[simard] memory remember: quarantined concept=bug-pattern confidence=0.40 (below gate)
+```
+
+---
+
+## `simard memory remember-procedure`
+
+Write a single recurring procedure.
+
+```text
+Usage: simard memory remember-procedure
+         --name <PROCEDURE_NAME>
+         --step <TEXT> [--step <TEXT> ...]
+         [--prerequisite <TEXT> ...]
+         [--source-episode-id <ID> ...]
+         [--pass-id <OPAQUE>]
+         [state-root]
+```
+
+| Flag | Required | Meaning |
+|------|----------|---------|
+| `--name <NAME>` | yes | Stable procedure handle (e.g. `ci-fix:auto`). Upsert-by-name — reuse the same name across passes to reinforce rather than duplicate. |
+| `--step <TEXT>` | yes (repeatable, ≥1) | One ordered step. Repeat the flag to add steps in order. |
+| `--prerequisite <TEXT>` | no (repeatable) | A prerequisite for the procedure. |
+| `--source-episode-id <ID>` | no (repeatable) | Episode `node_id`s the procedure was distilled from; the daemon writes **one `PROCEDURE_DERIVES_FROM` edge per id**. |
+| `--pass-id <OPAQUE>` | no | Pass attribution, as above. |
+| `state-root` (positional) | no | Explicit state root; same resolution as `remember`. |
+
+Exit codes: `0` success (idempotent upsert-by-name), `2` usage error (missing
+`--name` or no `--step`), `3` no reachable daemon **or** the write errored.
+There is no `4` — a procedure is not gate-quarantined. Procedure writes are
+**idempotent by name**, so a retried pass reinforces the existing procedure
+instead of creating a duplicate.
+
+### Example
+
+```bash
+simard memory remember-procedure \
+  --name ci-fix:auto \
+  --step "reproduce the failing job locally with the same runner image" \
+  --step "bisect the offending step" \
+  --step "apply the minimal fix and re-run the job" \
+  --source-episode-id ep_C --source-episode-id ep_D
+```
+
+---
+
+## Relationship to the daemon
+
+`remember` / `remember-procedure` are **write** commands and therefore require a
+running OODA daemon that holds the store and serves the memory socket — the same
+socket the read-only `stats` / `dump` commands opportunistically use. Unlike
+`import`, they are **not** a stopped-daemon operation: they are designed to be
+called *by an agentic step the daemon itself scheduled*, while the daemon is up
+and listening.
+
+If the socket is absent (exit `3`), the caller does not fall back to writing the
+on-disk store directly and does not fall back to printing an envelope — the
+distillation scheduler simply treats the pass as skipped and retries next cycle.
+This preserves the D4 invariant: facts are committed **only** through the live
+write endpoint, never marshalled through a channel that must be parsed.
+
+---
+
+## Security notes
+
+- The write-boundary **gate is server-side and authoritative**. This CLI cannot
+  set a confidence the server honors, bypass quarantine, or supply a pre-scored
+  fact: `--confidence` is accepted only as a hint the server **ignores** (it
+  re-derives confidence from grounding + content + concept), and there is no flag
+  to skip the gate.
+- Fact content is treated as **opaque data**: it is never interpolated into a
+  shell, a path, or a query. The `--pass-id` is opaque and never logged with the
+  fact body.
+- Only the **local** Unix socket is used; there is no network exposure. The
+  socket is created `0600` inside a `0700` directory, and the IPC handler
+  length-caps every field and enforces a maximum frame size. See
+  [write-boundary gate → input validation](./distill-write-boundary-gate.md#input-validation-framing).
diff --git a/docs/reference/telemetry-metrics.md b/docs/reference/telemetry-metrics.md
index 42b287bc..67496b75 100644
--- a/docs/reference/telemetry-metrics.md
+++ b/docs/reference/telemetry-metrics.md
@@ -1,7 +1,7 @@
 ---
 title: Telemetry metrics reference
 description: The unified Simard telemetry facade and OpenTelemetry metrics pipeline — the counter_add/gauge_set/histogram_record facade, the simard.<area>.<name> metric catalog with attributes and types, the in-process registry and metrics_snapshot.json flush, SdkMeterProvider init and endpoint-gated OTLP export, cardinality bounding, and the configuration knobs.
-last_updated: 2026-07-03
+last_updated: 2026-07-06
 review_schedule: as-needed
 owner: simard
 doc_type: reference
@@ -11,6 +11,8 @@ related:
   - ../howto/simard-status.md
   - ./runtime-contracts.md
   - ./daily-budget-display-guard.md
+  - ../architecture/distillation-semantic-handoff.md
+  - ./distill-write-boundary-gate.md
 ---
 
 # Telemetry metrics reference
@@ -84,7 +86,7 @@ fact from a more authoritative place:
 
 | Metric | Emitted today | Notes |
 |---|---|---|
-| `simard.distill.*` | ✅ `distillation.rs` | ok + parse_fail + facts/procedures/episodes_marked |
+| `simard.distill.*` | ✅ `distillation.rs` | ok + facts/procedures/episodes_marked (the `parse_fail` result was **removed** in #2679 — there is no parse) |
 | `simard.brain.decision` / `.escalations` | ✅ `judgment_record::push` | every decision, phase + parse outcome |
 | `simard.brain.ladder_exhausted` | ✅ `recipe_brain::run_brain_ladder` | decide/orient ladder fully exhausted |
 | `simard.engineer.spawned` / `.exited` / `.active` | ✅ `agent_spawn.rs` | brackets the in-process session |
@@ -105,11 +107,17 @@ enumerated sets shown; anything outside the set is coerced to `other`.
 
 | Metric | Type | Attributes | Meaning |
 |---|---|---|---|
-| `simard.distill.runs` | counter | `result` = `ok` \| `parse_fail` | one distillation run completed; `parse_fail` is the "recipe output did not contain a parseable …" failure |
-| `simard.distill.facts` | counter | — | facts produced by a run |
-| `simard.distill.procedures` | counter | — | procedures produced by a run |
+| `simard.distill.runs` | counter | `result` = `ok` | one distillation run whose agentic commit completed. The former `parse_fail` value was **removed** in [#2679](https://github.com/rysweet/Simard/issues/2679): the distiller now writes facts directly into memory via [`simard memory remember`](./simard-memory-remember-cli.md), so there is no scraped document to parse and no parse to fail. |
+| `simard.distill.facts` | counter | — | facts **accepted by the write-boundary gate** for a run, sourced from the per-`pass_id` write ledger (not a parsed array length). |
+| `simard.distill.procedures` | counter | — | procedures written by a run |
 | `simard.distill.episodes_marked` | counter | — | episodes marked processed by a run |
 
+> **Removed in #2679:** the `simard.distill.runs{result="parse_fail"}` series and
+> the derived `distill_parse_success_rate`. Dashboards/alerts keyed on either
+> will read empty; track `result="ok"` and `simard.distill.facts` instead. See
+> [Distillation semantic handoff](../architecture/distillation-semantic-handoff.md)
+> and [Distill write-boundary gate](./distill-write-boundary-gate.md).
+
 Migrated from the human line
 `[simard] distill: N episodes -> F facts, P procedures, M marked`, which is
 still emitted verbatim.
diff --git a/mkdocs.yml b/mkdocs.yml
index 951320e7..c3feb7b4 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -74,6 +74,7 @@ nav:
     - Cognitive Memory — Library Adapter: architecture/cognitive-memory-library-adapter.md
     - Episode Ingestion Policy & Promotion: architecture/episode-ingestion-policy.md
     - Episode Distillation: architecture/episode-distillation.md
+    - Distillation Semantic Handoff: architecture/distillation-semantic-handoff.md
     - Gym Eval Engine — Library Adapter: architecture/gym-eval-library-adapter.md
     - Unified Meeting Backend: architecture/unified-meeting-backend.md
     - Conversation Channels: architecture/conversation-channel.md
@@ -197,6 +198,7 @@ nav:
     - View Agent Terminal Logs: howto/view-agent-terminal-logs.md
     - Run Dashboard E2E Tests: howto/run-dashboard-e2e-tests.md
     - Capture and Diagnose a Failing Distill Sample: howto/capture-and-diagnose-a-failing-distill-sample.md
+    - Verify the Distillation Semantic Handoff: howto/verify-the-distillation-semantic-handoff.md
     - Measure Recall Precision (Hybrid): howto/measure-recall-precision-hybrid.md
     - Read Simard Status: howto/simard-status.md
     - Watch Overseer Activity: howto/watch-overseer-activity.md
@@ -258,6 +260,8 @@ nav:
     - Distill Recipe-Output Capture: reference/distill-recipe-output-capture.md
     - Base-Type Adapters: reference/base-type-adapters.md
     - Memory Introspection CLI: reference/simard-memory-cli.md
+    - Memory Write CLI (remember): reference/simard-memory-remember-cli.md
+    - Distill Write-Boundary Gate: reference/distill-write-boundary-gate.md
     - Cognitive-Memory Provenance (DERIVES_FROM): reference/cognitive-memory-provenance.md
     - Cognitive-Memory Bootstrap Procedures: reference/cognitive-memory-bootstrap-procedures.md
     - Cognitive-Memory Client Helpers: reference/cognitive-memory-client-helpers.md
diff --git a/prompt_assets/simard/recipes/distill-episodes.yaml b/prompt_assets/simard/recipes/distill-episodes.yaml
index 80d0b0a3..1475a5f6 100644
--- a/prompt_assets/simard/recipes/distill-episodes.yaml
+++ b/prompt_assets/simard/recipes/distill-episodes.yaml
@@ -1,69 +1,67 @@
-# distill-episodes.yaml — Recipe for PR-B episode distillation (issue #2281).
+# distill-episodes.yaml — Recipe for episode distillation (issue #2281; semantic
+# handoff #2679).
 #
-# Periodic many-to-few extraction: given a batch of up to 50 recent
-# episodes, classify each into one of three concept labels (or `skip`)
-# and emit a single JSON envelope of derived facts.
+# Periodic many-to-few extraction: given a batch of up to 50 recent episodes,
+# classify each into one of three concept labels (or `skip`) and commit the
+# derived facts DIRECTLY into cognitive memory.
+#
+# ## What changed in #2679
+#
+# The distiller no longer PRINTS or WRITES a `{ "facts": [...] }` envelope for
+# Simard to scrape back out of recipe stdout and hand-deserialize. That
+# deserialize was the single failure surface — one trailing comma, one stray log
+# line, one ANSI escape from the launcher banner made the strict parse fail and
+# discarded the ENTIRE batch (the #2658/#2679 parse-fail mode). Instead the
+# distiller is now a TRUE agentic step whose WRITES are its output: it calls the
+# `simard memory remember` tool once per fact. Those writes land in the same
+# store Simard reads from, through the daemon's authoritative write-boundary gate
+# (grounding + reliability scoring + quarantine + dedup are all server-side).
+# There is no return document for anyone to parse, so a malformed token can no
+# longer discard anything.
 #
 # Context vars (passed via -c):
 #   episodes_path — ABSOLUTE path to a file containing the JSON array of episode
 #     objects, each { id, source_label, temporal_index, content } (issues
 #     #2640/#2692). A batch of up to 50 full-text episodes is unbounded, so it is
-#     delivered via a file and never inlined into argv — it can never overflow
-#     ARG_MAX and fail the spawn with E2BIG. The agent READS this file.
-#   facts_output_path — ABSOLUTE path to the file the agent MUST write its JSON
-#     envelope to (issues #2622/#2619). This is the ONLY channel Simard reads the
-#     result from; stdout is ignored, so the copilot launcher banner and log
-#     lines can never contaminate the parse.
-#   strict_json_instruction — format-reinforcement sentence appended to the
-#     prompt on an in-cycle retry after a transient parse miss (issue #2468).
-#     Empty on the first attempt; set to a "write ONLY the JSON object to the
-#     facts file" reminder on retry. Interpolated via the pure
-#     `{{strict_json_instruction}}` substitution, so no conditional templating
-#     is required.
+#     delivered via a file and never inlined into argv. The agent READS this file.
+#   memory_socket — ABSOLUTE path to the OODA daemon's memory IPC socket. The
+#     `simard memory remember` tool also reads this from the SIMARD_MEMORY_SOCKET
+#     environment variable, which the distill subprocess exports, so a bare
+#     `simard memory remember ...` reaches the right daemon. This var is provided
+#     for reference / explicit `--` state-root use.
 #
-# Output: the agent WRITES a single JSON object of the form below to the file at
-# `{{facts_output_path}}` (NOT to stdout):
-#   {
-#     "facts": [
-#       { "concept": "pr-pattern" | "bug-pattern" | "lesson-learned",
-#         "content": "<short, declarative summary>",
-#         "source_episode_id": "<id of the episode this fact derives from>" }
-#     ],
-#     "procedures": [
-#       { "name": "<short procedure name>",
-#         "steps": ["<step 1>", "<step 2>", ...],
-#         "source_episode_ids": ["<id>", "<id>", ...] }
-#     ]
-#   }
+# Pass-id ledger (issue #2679): the distill subprocess also exports a
+# SIMARD_DISTILL_PASS_ID environment variable that tags every fact this pass
+# commits, so the daemon can count accepted facts on a path with no return
+# document. The `simard memory remember` tool reads that env var itself — the
+# agent MUST NOT pass a `--pass-id` flag (it is intentionally absent from the
+# flag list below). Inheriting the pass id via the environment, rather than
+# relying on the agent to echo a flag, is what keeps the fact count correct
+# without reintroducing an LLM-formatting failure surface.
 #
-# `procedures` is optional (issue #2327): emit it only when the batch reveals
-# a RECURRING action sequence worth promoting into a reusable procedure.
+# Output: NONE on stdout. The agent's fact/procedure WRITES (via the tool) are
+# the entire output. Whatever the agent prints to the terminal is ignored —
+# Simard interprets this recipe by its EXIT STATUS alone.
 #
-# See docs/architecture/episode-distillation.md for the full contract,
-# concept-label semantics, and retry-safety invariants.
+# See docs/architecture/distillation-semantic-handoff.md for the full contract,
+# concept-label semantics, retry-safety invariants, and the write-boundary gate.
 
 name: "distill-episodes"
-description: "Distill a batch of recent episodes into semantic facts"
-version: "1.0.0"
+description: "Distill a batch of recent episodes into semantic facts, committed directly to memory"
+version: "2.0.0"
 author: "Simard"
 tags: ["simard", "memory", "distillation"]
 
 context:
-  # Empty by default; the distill subprocess overrides this with a format
-  # reinforcement sentence (-c strict_json_instruction=...) on a retry after a
-  # transient parse miss (issue #2468). Declared so the `{{strict_json_instruction}}`
-  # substitution always resolves, even when the recipe is run without the override.
-  strict_json_instruction: ""
-  # Empty by default; the distill subprocess overrides this with the absolute
-  # path of the per-invocation facts file the agent must write (issues
-  # #2622/#2619). Declared so the `{{facts_output_path}}` substitution always
-  # resolves, even when the recipe is run without the override.
-  facts_output_path: ""
   # Empty by default; the distill subprocess overrides this with the absolute
   # path of the per-invocation episodes file the agent must read (issues
   # #2640/#2692). Declared so the `{{episodes_path}}` substitution always
   # resolves, even when the recipe is run without the override.
   episodes_path: ""
+  # Empty by default; the distill subprocess overrides this with the absolute
+  # path of the daemon's memory IPC socket (issue #2679). Declared so the
+  # `{{memory_socket}}` substitution always resolves.
+  memory_socket: ""
 
 steps:
   - id: "distill"
@@ -73,15 +71,15 @@ steps:
       You are the **semantic distiller** for Simard's cognitive memory.
       You are given a batch of recent **episodes** (events that happened
       during prior OODA cycles) and you produce a small number of
-      durable **semantic facts** that will be stored alongside the
-      episodes for future retrieval.
+      durable **semantic facts** that you WRITE DIRECTLY into cognitive
+      memory using the `simard memory remember` command-line tool.
 
       ## Input
 
       The batch of episodes is a JSON array. Each entry has:
 
       - `id` — opaque episode identifier you must echo back as
-        `source_episode_id` when you derive a fact from it.
+        `--source-episode-id` when you derive a fact from it.
       - `source_label` — short tag describing where the episode came
         from (e.g. `goal-curator`, `consolidation-persistence`).
       - `temporal_index` — monotonic ordering key (NOT a wall-clock
@@ -99,24 +97,35 @@ steps:
       ## Your job
 
       Walk the episodes and decide which are worth distilling. For each
-      episode you keep, emit **exactly one** fact with:
+      episode you keep, WRITE **exactly one** fact into memory by running
+      the `simard memory remember` tool with these scalar flags:
 
-      - `concept` — one of:
+      - `--concept` — one of:
         - `pr-pattern` — pull-request shaped events: merge sequences,
           CI patterns, review patterns, scope-creep observations.
         - `bug-pattern` — bug reproductions, root causes, recurring
           failure modes, environmental fragility.
         - `lesson-learned` — decisions made, tradeoffs encountered,
           things that surprised the engineer, retrospective insights.
-      - `content` — a **short, declarative** sentence capturing the
+      - `--content` — a **short, declarative** sentence capturing the
         durable lesson (≤ 200 chars is ideal). NOT a transcript; NOT a
-        timestamp; just the takeaway.
-      - `source_episode_id` — the `id` from the source episode,
-        verbatim.
+        timestamp; just the takeaway. Quote it so spaces are preserved.
+      - `--source-episode-id` — the `id` from the source episode,
+        verbatim. This is what grounds the fact; a fact whose id is not in
+        the batch is quarantined by the server, so ALWAYS pass a real id.
+
+      Run ONE command per fact. For example:
+
+      ```
+      simard memory remember \
+        --concept=bug-pattern \
+        --content="empty outcome list panics the cycle loop" \
+        --source-episode-id=<id-from-input>
+      ```
 
       Episodes that are pure noise (startup logs, simple retries,
       progress chatter, exact duplicates of earlier episodes) should be
-      **skipped** — do NOT emit a fact for them. The system records
+      **skipped** — do NOT run `remember` for them. The system records
       that you saw them via a separate mechanism, so dropping low-value
       episodes is the correct call.
 
@@ -124,59 +133,36 @@ steps:
 
       If — and only if — the batch reveals a **recurring action
       sequence** (the same multi-step workflow appearing across two or
-      more episodes), ALSO emit a `procedure` capturing it as a reusable
-      playbook:
+      more episodes), ALSO write a procedure with the companion tool:
 
-      - `name` — a short, stable handle (e.g. `ci-fix:auto`,
+      ```
+      simard memory remember-procedure \
+        --name=ci-fix:auto \
+        --step="read the failing job log" \
+        --step="reproduce locally" \
+        --step="apply the minimal fix" \
+        --source-episode-id=<id> --source-episode-id=<id>
+      ```
+
+      - `--name` — a short, stable handle (e.g. `ci-fix:auto`,
         `pr:merge-flow`). Reuse the same name across batches for the same
         workflow so the store reinforces rather than duplicates it.
-      - `steps` — the ordered steps of the workflow, each a short
-        imperative sentence.
-      - `source_episode_ids` — the `id`s of the episodes the procedure
-        was distilled from (≥ 1).
+      - `--step` — one per step, in order (repeat the flag).
+      - `--source-episode-id` — the `id`s of the episodes the procedure
+        was distilled from (≥ 1; repeat the flag).
 
       Do NOT invent procedures for one-off events. A batch with no
-      recurring workflow emits an empty `procedures` array.
+      recurring workflow writes no procedure.
 
       ## Output
 
-      **Write** the following JSON object — and NOTHING else — to the file at
-      the absolute path:
-
-      ```
-      {{facts_output_path}}
-      ```
-
-      Use your file-writing tool to create/overwrite that exact file with a
-      single JSON object. Do NOT print the JSON to the terminal as your answer,
-      and do NOT wrap it in prose or a markdown fence inside the file — the file
-      must contain only the JSON object:
-
-      ```json
-      {
-        "facts": [
-          {
-            "concept": "pr-pattern" | "bug-pattern" | "lesson-learned",
-            "content": "<short declarative sentence>",
-            "source_episode_id": "<id from input>"
-          }
-        ],
-        "procedures": [
-          {
-            "name": "<short procedure name>",
-            "steps": ["<step 1>", "<step 2>"],
-            "source_episode_ids": ["<id from input>"]
-          }
-        ]
-      }
-      ```
-
-      This file is the ONLY channel that is read: anything you print to the
-      terminal is ignored. If nothing in the batch is worth keeping, still write
-      the file with `{"facts": [], "procedures": []}`.
+      There is **no output file and no JSON to print**. Your `simard memory
+      remember` / `remember-procedure` invocations ARE the output. The server
+      grounds, scores, and either stores or quarantines each fact and prints its
+      disposition; you do not need to parse or report that. If nothing in the
+      batch is worth keeping, simply run no `remember` commands and finish
+      successfully.
 
       Do not invent new concept labels. Do not invent episode ids. Do not
-      include the literal string `skip` in the `concept` field — skipped
-      episodes simply contribute no entry to the `facts` array.
-
-      {{strict_json_instruction}}
+      pass the literal string `skip` as a concept — a skipped episode simply
+      gets no `remember` call.
diff --git a/src/cognitive_memory/library_adapter.rs b/src/cognitive_memory/library_adapter.rs
index e9147822..476ab3e1 100644
--- a/src/cognitive_memory/library_adapter.rs
+++ b/src/cognitive_memory/library_adapter.rs
@@ -1166,6 +1166,47 @@ impl CognitiveMemoryOps for LibraryCognitiveMemory {
         Ok(())
     }
 
+    fn episode_exists(&self, node_id: &str) -> SimardResult<bool> {
+        // Issue #2679: grounding primitive for the distillation write-boundary
+        // gate. The library has no direct "does this episode id exist" lookup,
+        // so we scan the same unfiltered enumeration `list_all_episodes` uses
+        // (`get_episodes(_, true)`, newest-first, INCLUDING compressed episodes)
+        // and short-circuit on the first id match. Compressed episodes are
+        // included so a fact citing a consolidated source still grounds. A
+        // grounding check is a read; it never mutates the store.
+        let node_id = node_id.trim();
+        if node_id.is_empty() {
+            return Ok(false);
+        }
+        Ok(self
+            .lock()?
+            .get_episodes(usize::MAX, true)
+            .iter()
+            .any(|e| e.node_id == node_id))
+    }
+
+    fn any_episode_exists(&self, node_ids: &[String]) -> SimardResult<bool> {
+        // Batch grounding for the write-boundary gate (issue #2679): materialize
+        // the episode enumeration ONCE (the same unfiltered, compressed-inclusive
+        // `get_episodes(_, true)` scan `episode_exists` uses) and test every
+        // candidate id against it, instead of re-materializing the full set once
+        // per cited id. Trims the per-fact grounding cost from O(cited·episodes)
+        // to O(episodes). A grounding check is a read; it never mutates the store.
+        let wanted: Vec<&str> = node_ids
+            .iter()
+            .map(|s| s.trim())
+            .filter(|s| !s.is_empty())
+            .collect();
+        if wanted.is_empty() {
+            return Ok(false);
+        }
+        Ok(self
+            .lock()?
+            .get_episodes(usize::MAX, true)
+            .iter()
+            .any(|e| wanted.iter().any(|w| e.node_id == *w)))
+    }
+
     fn list_undistilled_episodes(&self, limit: u32) -> SimardResult<Vec<CognitiveEpisode>> {
         // De-fork Phase 2b (issue #2307): episode distillation now runs against
         // this backend. The library returns this agent's not-yet-distilled
diff --git a/src/cognitive_memory/mod.rs b/src/cognitive_memory/mod.rs
index 7b51bdd5..31234453 100644
--- a/src/cognitive_memory/mod.rs
+++ b/src/cognitive_memory/mod.rs
@@ -461,6 +461,39 @@ pub trait CognitiveMemoryOps: Send + Sync {
         Ok(())
     }
 
+    /// Report whether an episode with `node_id` exists in this store (issue
+    /// #2679).
+    ///
+    /// This is the **grounding** primitive for the distillation write-boundary
+    /// gate: when the distiller agent commits a fact through the memory IPC
+    /// socket, the server holds no in-memory batch, so it grounds the fact by an
+    /// existence lookup — the fact is grounded iff at least one of its cited
+    /// `source_episode_ids` resolves to a real episode node here.
+    ///
+    /// Default impl returns `false` (fail-closed: an unresolvable id is treated
+    /// as ungrounded) so non-graph backends (legacy Python bridge, IPC client,
+    /// test stubs) keep compiling; only [`LibraryCognitiveMemory`] overrides it
+    /// to look the episode up in the store.
+    fn episode_exists(&self, _node_id: &str) -> SimardResult<bool> {
+        Ok(false)
+    }
+
+    /// Batch grounding check: report whether *any* of `node_ids` resolves to a
+    /// real episode node in this store (issue #2679).
+    ///
+    /// This is the batch form of [`episode_exists`](Self::episode_exists) the
+    /// distillation write-boundary gate uses to ground a fact against *all* of
+    /// its cited `source_episode_ids` at once. The default impl simply probes
+    /// each id via [`episode_exists`](Self::episode_exists) (fail-closed per id),
+    /// so every backend keeps working unchanged; [`LibraryCognitiveMemory`]
+    /// overrides it to materialize the episode set ONCE per call instead of once
+    /// per cited id, avoiding an O(cited·episodes) re-scan on the write hot path.
+    fn any_episode_exists(&self, node_ids: &[String]) -> SimardResult<bool> {
+        Ok(node_ids
+            .iter()
+            .any(|id| self.episode_exists(id).unwrap_or(false)))
+    }
+
     /// Return up to `limit` undistilled episodes, newest first.
     ///
     /// Default impl returns empty, which makes the distillation pass a
diff --git a/src/fact_reliability.rs b/src/fact_reliability.rs
new file mode 100644
index 00000000..bee19535
--- /dev/null
+++ b/src/fact_reliability.rs
@@ -0,0 +1,256 @@
+//! Shared, pure per-fact reliability scorer for distilled semantic facts
+//! (issue #2679, homing the ISAO gate first landed in #2433).
+//!
+//! ## Why this module exists
+//!
+//! Post-#2679 the distillation RESULT path no longer parses an agent-authored
+//! `{ "facts": [...] }` document. Instead the distiller agentic step writes each
+//! fact DIRECTLY through the cognitive-memory write boundary. The reliability
+//! gate that used to run in Simard *after the parse* therefore moves to the
+//! write boundary and is applied **per fact**. Two seams reach that boundary:
+//!
+//!   1. the IPC server's `StoreFactGated` dispatch arm (the authoritative,
+//!      server-side gate for the real subprocess path), and
+//!   2. the in-process `DistillFactSink` used by the deterministic test stubs.
+//!
+//! To keep those two seams in lock-step — and to *reduce* the
+//! `memory_consolidation` fork per the G2 memory-architecture constraint — the
+//! scorer lives here as one shared, pure function. Both seams call the SAME
+//! [`score_fact_reliability`], so a fact scores identically no matter which
+//! boundary writes it.
+//!
+//! ## Contract vs. the legacy `assess_fact_reliability`
+//!
+//! The legacy scorer took the whole pass batch so it could compute a
+//! **corroboration** term. That batch is unavailable in a per-fact IPC call, so
+//! this scorer is a pure function of exactly one fact plus a resolved
+//! `grounded: bool`. Grounding is resolved *before* the call (batch-membership
+//! for the in-process sink; store-existence for the IPC handler). The
+//! corroboration term is deliberately dropped: it was disposition-neutral (it
+//! only nudged an already-storable 0.9 → 1.0, never flipped store↔quarantine),
+//! so excluding it lets both seams agree on every store/quarantine decision.
+
+/// ISAO reliability gate threshold (issue #2433). A fact whose self-assessed
+/// reliability is below this is **quarantined** — not promoted into semantic
+/// memory. Tuned so a fact with valid provenance, a known concept label, and
+/// non-trivial content clears the bar, while a fact with hallucinated
+/// provenance or empty content does not.
+pub const RELIABILITY_THRESHOLD: f64 = 0.5;
+
+/// How many same-`concept` priors the identity-dedup step in
+/// [`commit_gated_fact`] inspects when deciding whether a new fact merely
+/// restates an equal-or-stronger existing fact. `search_facts` returns priors
+/// ranked strongest-first and filtered to `>= confidence`, so a genuine
+/// equal-or-stronger duplicate surfaces within the first few results; the
+/// window is kept intentionally small to bound the per-write query cost on the
+/// distillation hot path.
+const DEDUP_PRIOR_SCAN_LIMIT: u32 = 5;
+
+/// The closed concept-label set the distillation recipe is constrained to. A
+/// fact whose concept does not canonicalize into this set is off-spec and loses
+/// the concept-validity component of its reliability score (but is NOT dropped —
+/// concept validity is a nudge, not a gate).
+pub const KNOWN_CONCEPTS: &[&str] = &["pr-pattern", "bug-pattern", "lesson-learned"];
+
+/// Canonicalize a recipe-emitted concept label to one of [`KNOWN_CONCEPTS`], or
+/// `None` if it is genuinely off-spec.
+///
+/// The distillation recipe's prompt constrains the label to the closed set
+/// `{pr-pattern, bug-pattern, lesson-learned}`, but an LLM routinely varies the
+/// *surface form* of a label it clearly intends: title/upper case, surrounding
+/// whitespace or quotes/sentence punctuation, and space/underscore separators.
+/// Canonicalization folds case, trims surrounding whitespace/quote/sentence
+/// punctuation, and unifies `_`/space→`-` (collapsing repeated hyphens) before an
+/// EXACT match against the three labels. A concept that does not normalize to one
+/// of them still returns `None`. The three labels are lexically distinct, so no
+/// genuinely different concept can alias onto another.
+pub fn canonical_concept(raw: &str) -> Option<&'static str> {
+    let trimmed = raw.trim().trim_matches(|c: char| {
+        c.is_whitespace() || matches!(c, '"' | '\'' | '`' | '.' | ',' | ':' | ';')
+    });
+
+    // Fold case, unify separators (`_` and interior spaces behave as `-`) and
+    // collapse runs of hyphens in a single pass — folding the lowercase into this
+    // loop avoids a second heap allocation for a separately-lowercased string.
+    // Trim any leading/trailing hyphens the folding produced afterwards.
+    let mut canon = String::with_capacity(trimmed.len());
+    let mut prev_hyphen = false;
+    for ch in trimmed.chars() {
+        let c = if ch == '_' || ch == ' ' {
+            '-'
+        } else {
+            ch.to_ascii_lowercase()
+        };
+        if c == '-' {
+            if !prev_hyphen {
+                canon.push('-');
+            }
+            prev_hyphen = true;
+        } else {
+            canon.push(c);
+            prev_hyphen = false;
+        }
+    }
+    let canon = canon.trim_matches('-');
+
+    match canon {
+        "pr-pattern" => Some("pr-pattern"),
+        "bug-pattern" => Some("bug-pattern"),
+        "lesson-learned" => Some("lesson-learned"),
+        _ => None,
+    }
+}
+
+/// Self-assess the reliability of one distilled fact (issue #2433, BGML's
+/// *information self-assessment ownership*, §IV). Returns a confidence score in
+/// `[0.0, 1.0]` from cheap, locally-available signals — no extra LLM call:
+///
+/// | Signal | Weight | Rationale |
+/// |--------|--------|-----------|
+/// | **Provenance grounding** | 0.5 | Resolved by the caller: batch-membership for the in-process sink, store-existence for the IPC handler. A source that cannot be grounded is unverifiable / hallucinated provenance — the strongest unreliability signal. |
+/// | **Content quality** | ≤0.3 | Empty / whitespace-only content carries no information and is a HARD gate (score `0.0`); otherwise ≥3 words earns the full weight, 1–2 words a partial 0.15. |
+/// | **Concept validity** | 0.1 | Awarded when the concept canonicalizes into [`KNOWN_CONCEPTS`]. |
+///
+/// A nominal fact (grounded, ≥3 words, known concept) scores `0.9`. Because
+/// grounding (0.5) is *necessary* to clear [`RELIABILITY_THRESHOLD`] (0.5), an
+/// ungrounded fact tops out at `0.4` (content + concept) and an empty fact scores
+/// `0.0`; both are quarantined.
+pub fn score_fact_reliability(concept: &str, content: &str, grounded: bool) -> f64 {
+    // (0) Hard gate: empty / whitespace-only content carries no information and
+    // is quarantined unconditionally, regardless of how trustworthy its
+    // provenance looks. We only need the 0 / 1–2 / ≥3 word bucket, so stop after
+    // the third word instead of scanning the whole (up to 64 KiB) content.
+    let words = content.split_whitespace().take(3).count();
+    if words == 0 {
+        return 0.0;
+    }
+
+    let mut score = 0.0_f64;
+
+    // (1) Provenance grounding — the dominant, *necessary* signal.
+    if grounded {
+        score += 0.5;
+    }
+
+    // (2) Content quality (content is non-empty here — see the hard gate above).
+    if words >= 3 {
+        score += 0.3;
+    } else {
+        score += 0.15;
+    }
+
+    // (3) Concept validity — a nudge, not a gate.
+    if canonical_concept(concept).is_some() {
+        score += 0.1;
+    }
+
+    score.clamp(0.0, 1.0)
+}
+
+/// Thin predicate over [`score_fact_reliability`]: a fact clears the promotion
+/// gate iff its score is at or above [`RELIABILITY_THRESHOLD`]. Both write-
+/// boundary seams share this identical store/quarantine decision.
+pub fn fact_passes_gate(concept: &str, content: &str, grounded: bool) -> bool {
+    score_fact_reliability(concept, content, grounded) >= RELIABILITY_THRESHOLD
+}
+
+/// Disposition of one write-boundary gate decision (issue #2679), returned by
+/// [`commit_gated_fact`].
+#[derive(Debug, Clone, PartialEq)]
+pub enum FactGateDecision {
+    /// The fact cleared the gate and was persisted with the gate-computed
+    /// `confidence`; `node_id` is the new fact node's id.
+    Stored { confidence: f64, node_id: String },
+    /// The fact was blocked — either below [`RELIABILITY_THRESHOLD`] or an
+    /// equal-or-stronger prior of the same identity already exists. Nothing was
+    /// written. `confidence` is still the gate-computed score (a caller can
+    /// compare it against [`RELIABILITY_THRESHOLD`] to tell a low-reliability
+    /// quarantine from a dedup skip).
+    Quarantined { confidence: f64 },
+}
+
+impl FactGateDecision {
+    /// `true` when the fact was persisted.
+    pub fn stored(&self) -> bool {
+        matches!(self, Self::Stored { .. })
+    }
+
+    /// The gate-computed reliability score, available for both dispositions.
+    pub fn confidence(&self) -> f64 {
+        match self {
+            Self::Stored { confidence, .. } | Self::Quarantined { confidence } => *confidence,
+        }
+    }
+}
+
+/// The single shared write-boundary gate (issue #2679): **score → threshold →
+/// identity-dedup → persist**, applied to one fact.
+///
+/// Both seams that reach the write boundary call this so a fact stores or
+/// quarantines identically no matter which boundary writes it:
+///
+///   1. the IPC server's `StoreFactGated` handler (server-side, real subprocess
+///      path), and
+///   2. the in-process `DistillFactSink` used by the deterministic test stubs.
+///
+/// `grounded` is resolved by the caller — store-existence for the server,
+/// batch-membership for the in-process sink — because the notion of "grounded"
+/// differs per seam. Everything downstream of grounding is identical and lives
+/// here:
+///
+///   - Confidence is ALWAYS [`score_fact_reliability`]'s output, never a client
+///     hint.
+///   - Below [`RELIABILITY_THRESHOLD`] → [`FactGateDecision::Quarantined`].
+///   - A weaker-or-equal restatement never clobbers an existing equal-or-stronger
+///     fact of the same identity (`concept` + trimmed `content`); such a fact is
+///     also quarantined (its score still cleared the threshold, so the caller can
+///     distinguish it by `confidence >= RELIABILITY_THRESHOLD`).
+///   - Survivors persist via `store_fact_with_provenance` with the gate-computed
+///     confidence and the source-episode provenance edges.
+pub fn commit_gated_fact(
+    memory: &dyn crate::cognitive_memory::CognitiveMemoryOps,
+    concept: &str,
+    content: &str,
+    grounded: bool,
+    source_id: &str,
+    tags: &[String],
+    source_episode_ids: &[String],
+) -> crate::error::SimardResult<FactGateDecision> {
+    let confidence = score_fact_reliability(concept, content, grounded);
+
+    // Threshold quarantine.
+    if confidence < RELIABILITY_THRESHOLD {
+        return Ok(FactGateDecision::Quarantined { confidence });
+    }
+
+    // Identity dedup: do not downgrade/duplicate an equal-or-stronger prior
+    // version of the *same* fact (concept + content). `search_facts` is queried
+    // with the new confidence as `min_confidence` so it returns only priors
+    // strong enough to block; the explicit `>=` is belt-and-suspenders against a
+    // backend that ignores the filter.
+    let new_content = content.trim();
+    let existing = memory
+        .search_facts(concept, DEDUP_PRIOR_SCAN_LIMIT, confidence)
+        .unwrap_or_default();
+    if existing
+        .iter()
+        .any(|f| f.content.trim() == new_content && f.confidence >= confidence)
+    {
+        return Ok(FactGateDecision::Quarantined { confidence });
+    }
+
+    // Persist with the gate-computed confidence and provenance edges.
+    let node_id = memory.store_fact_with_provenance(
+        concept,
+        content,
+        confidence,
+        source_id,
+        Some(tags),
+        None,
+        source_episode_ids,
+    )?;
+    Ok(FactGateDecision::Stored {
+        confidence,
+        node_id,
+    })
+}
diff --git a/src/fact_reliability_tests.rs b/src/fact_reliability_tests.rs
new file mode 100644
index 00000000..b678bd7f
--- /dev/null
+++ b/src/fact_reliability_tests.rs
@@ -0,0 +1,325 @@
+//! TDD (RED) tests for the shared `crate::fact_reliability` scorer (issue
+//! #2679).
+//!
+//! ## Why this module exists
+//!
+//! Post-#2679 the distillation RESULT path stops relying on parsing entirely:
+//! the distiller agentic step writes each fact DIRECTLY through the
+//! cognitive-memory gated write boundary. The ISAO reliability gate therefore
+//! moves from its old post-parse location in
+//! `distill_recent_episodes_with_runner` to the *write boundary* and is applied
+//! **per fact**. Two seams reach that boundary:
+//!
+//!   1. the IPC server's `StoreFactGated` dispatch arm (the authoritative,
+//!      server-side gate for the real subprocess path), and
+//!   2. the in-process `DistillFactSink` used by the deterministic test stubs.
+//!
+//! To keep those two seams in lock-step — and to *reduce* the
+//! `memory_consolidation` fork per the G2 memory-architecture constraint — the
+//! scorer is extracted into one shared, pure module `crate::fact_reliability`.
+//! Both seams call the SAME `score_fact_reliability`, so a fact scores
+//! identically no matter which boundary writes it.
+//!
+//! ## Key contract change vs. the legacy `assess_fact_reliability`
+//!
+//! The legacy scorer took `&[CognitiveEpisode]` and `&[DistilledFact]` (the
+//! whole pass batch) so it could compute a **corroboration** term. That batch is
+//! unavailable in a per-fact IPC call, so the shared scorer is a pure function
+//! of exactly one fact plus a resolved `grounded: bool`:
+//!
+//! ```ignore
+//! pub fn score_fact_reliability(concept: &str, content: &str, grounded: bool) -> f64;
+//! ```
+//!
+//! Grounding is resolved *before* the call (batch-membership for the in-process
+//! sink; store-existence for the IPC handler) and the corroboration term is
+//! deliberately dropped: it is disposition-neutral (it only nudges an
+//! already-storable 0.9 → 1.0, never flips store↔quarantine), so excluding it
+//! lets both seams agree on every store/quarantine decision.
+//!
+//! These tests reference `crate::fact_reliability::*`, which does not exist yet.
+//! The unresolved-path errors are the intended TDD red signal.
+
+use crate::fact_reliability::{
+    KNOWN_CONCEPTS, RELIABILITY_THRESHOLD, canonical_concept, fact_passes_gate,
+    score_fact_reliability,
+};
+
+// ───────────────────────────────────────────────────────────────────────────
+// Threshold + known-concept constants keep their #2433 values
+// ───────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn threshold_is_half_and_known_concepts_are_the_closed_set() {
+    assert_eq!(
+        RELIABILITY_THRESHOLD, 0.5,
+        "the promotion threshold is unchanged by #2679 — only its call site moves"
+    );
+    assert_eq!(
+        KNOWN_CONCEPTS,
+        &["pr-pattern", "bug-pattern", "lesson-learned"],
+        "the closed concept-label set is preserved verbatim from #2433"
+    );
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Pure per-fact scorer — documented value table (no batch / corroboration arg)
+// ───────────────────────────────────────────────────────────────────────────
+
+/// A fully-nominal fact (grounded, ≥3 content words, known concept) scores
+/// exactly 0.9 — at or above the legacy `DISTILL_FACT_CONFIDENCE` baseline — so
+/// good facts keep their downstream recall behaviour without the corroboration
+/// bonus.
+#[test]
+fn nominal_grounded_known_concept_scores_point_nine() {
+    let s = score_fact_reliability("bug-pattern", "empty outcome list panics cycle", true);
+    assert!(
+        (s - 0.9).abs() < 1e-9,
+        "grounded + ≥3 words + known concept must score 0.9, got {s}"
+    );
+    assert!(fact_passes_gate(
+        "bug-pattern",
+        "empty outcome list panics cycle",
+        true
+    ));
+}
+
+/// Grounding (0.5) is *necessary* to clear the threshold. An ungrounded fact
+/// tops out at 0.3 content + 0.1 concept = 0.4 and is always quarantined — with
+/// NO corroboration escape hatch (the term is gone).
+#[test]
+fn ungrounded_fact_tops_out_below_threshold() {
+    let s = score_fact_reliability("bug-pattern", "three or more words here", false);
+    assert!(
+        (s - 0.4).abs() < 1e-9,
+        "ungrounded fact must score 0.4 (content+concept only), got {s}"
+    );
+    assert!(
+        s < RELIABILITY_THRESHOLD,
+        "an ungrounded fact must never clear the promotion gate"
+    );
+    assert!(!fact_passes_gate(
+        "bug-pattern",
+        "three or more words here",
+        false
+    ));
+}
+
+/// Empty / whitespace-only content is a HARD gate: score 0.0 regardless of how
+/// trustworthy the provenance looks (a grounded-but-empty fact must NOT clear
+/// the gate at 0.5 grounding + 0.1 concept = 0.6).
+#[test]
+fn empty_content_is_a_hard_zero_even_when_grounded() {
+    assert_eq!(
+        score_fact_reliability("bug-pattern", "", true),
+        0.0,
+        "empty content is quarantined unconditionally"
+    );
+    assert_eq!(
+        score_fact_reliability("bug-pattern", "   \t\n ", true),
+        0.0,
+        "whitespace-only content is quarantined unconditionally"
+    );
+    assert!(!fact_passes_gate("bug-pattern", "", true));
+}
+
+/// Short (1–2 word) grounded content earns only the partial content weight:
+/// 0.5 grounding + 0.15 short-content + 0.1 concept = 0.75.
+#[test]
+fn grounded_short_content_known_concept_scores_point_seven_five() {
+    let s = score_fact_reliability("pr-pattern", "squash fixups", true);
+    assert!(
+        (s - 0.75).abs() < 1e-9,
+        "grounded + <3 words + known concept must score 0.75, got {s}"
+    );
+    assert!(fact_passes_gate("pr-pattern", "squash fixups", true));
+}
+
+/// An off-spec concept loses the 0.1 concept-validity component but a grounded,
+/// well-worded fact still clears the gate (0.5 + 0.3 = 0.8). Concept validity is
+/// a nudge, not a gate.
+#[test]
+fn grounded_unknown_concept_still_clears_gate() {
+    let s = score_fact_reliability("made-up-label", "three or more words here", true);
+    assert!(
+        (s - 0.8).abs() < 1e-9,
+        "grounded + ≥3 words + unknown concept must score 0.8, got {s}"
+    );
+    assert!(fact_passes_gate(
+        "made-up-label",
+        "three or more words here",
+        true
+    ));
+}
+
+/// The scorer is a *pure* function of its three arguments: identical inputs
+/// always yield identical scores (no batch, no time, no global state). This is
+/// the property that makes the stub-sink seam and the IPC-handler seam agree.
+#[test]
+fn scorer_is_pure_and_deterministic() {
+    let a = score_fact_reliability("lesson-learned", "prefer keyword overlap for recall", true);
+    let b = score_fact_reliability("lesson-learned", "prefer keyword overlap for recall", true);
+    assert_eq!(
+        a, b,
+        "the scorer must be deterministic for parity across seams"
+    );
+}
+
+/// Concept validity is case-insensitive (surface-form variants of a known label
+/// still earn the concept weight) but a genuinely off-spec label does not.
+#[test]
+fn concept_validity_is_case_insensitive() {
+    let good = score_fact_reliability("BUG-PATTERN", "three or more words here", true);
+    assert!(
+        (good - 0.9).abs() < 1e-9,
+        "an upper-case known concept must still earn the concept weight, got {good}"
+    );
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// canonical_concept moved here from distillation (shared by both seams)
+// ───────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn canonical_concept_folds_surface_variants() {
+    for (raw, want) in [
+        ("pr-pattern", "pr-pattern"),
+        ("PR-Pattern", "pr-pattern"),
+        ("BUG-PATTERN", "bug-pattern"),
+        (" bug-pattern ", "bug-pattern"),
+        ("Lesson-Learned", "lesson-learned"),
+        ("pr_pattern", "pr-pattern"),
+        ("lesson learned", "lesson-learned"),
+        ("pr--pattern", "pr-pattern"),
+    ] {
+        assert_eq!(canonical_concept(raw), Some(want), "variant {raw:?}");
+    }
+}
+
+#[test]
+fn canonical_concept_rejects_offspec() {
+    for raw in [
+        "made-up-label",
+        "skip",
+        "pr-patterns",
+        "pull-request",
+        "",
+        "   ",
+    ] {
+        assert_eq!(
+            canonical_concept(raw),
+            None,
+            "off-spec {raw:?} must be dropped"
+        );
+    }
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Gate parity: fact_passes_gate is exactly score >= RELIABILITY_THRESHOLD
+// ───────────────────────────────────────────────────────────────────────────
+
+/// `fact_passes_gate` must be a thin predicate over `score_fact_reliability`
+/// so both write-boundary seams share the identical store/quarantine decision.
+#[test]
+fn gate_predicate_matches_scored_threshold_across_a_matrix() {
+    let cases = [
+        ("bug-pattern", "empty outcome list panics cycle", true),
+        ("bug-pattern", "three or more words here", false),
+        ("bug-pattern", "", true),
+        ("pr-pattern", "squash fixups", true),
+        ("made-up-label", "three or more words here", true),
+        ("lesson-learned", "x", false),
+    ];
+    for (concept, content, grounded) in cases {
+        let expected = score_fact_reliability(concept, content, grounded) >= RELIABILITY_THRESHOLD;
+        assert_eq!(
+            fact_passes_gate(concept, content, grounded),
+            expected,
+            "gate predicate must equal (score >= threshold) for ({concept:?}, {content:?}, {grounded})"
+        );
+    }
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Shared write-boundary gate: commit_gated_fact drives score → threshold →
+// dedup → persist for BOTH seams, so the two can never drift.
+// ───────────────────────────────────────────────────────────────────────────
+
+/// A grounded, well-formed, known-concept fact clears the gate and is persisted;
+/// re-committing the identical fact is a dedup quarantine (its score still
+/// clears the threshold); and an ungrounded empty fact is a low-reliability
+/// quarantine (its score is below the threshold). These three dispositions are
+/// exactly what the IPC server seam and the in-process `DistillFactSink` seam
+/// now share, verbatim, by calling this one function.
+#[test]
+fn commit_gated_fact_stores_dedups_and_quarantines() {
+    use crate::cognitive_memory::{CognitiveMemoryOps, LibraryCognitiveMemory};
+    use crate::fact_reliability::{FactGateDecision, commit_gated_fact};
+
+    let mem = LibraryCognitiveMemory::in_memory().expect("in-memory db");
+    let ep = mem
+        .store_episode("episode payload for gate test", "engineer-cycle", None)
+        .expect("store_episode");
+    let source = format!("distill:{ep}");
+    let tags = [String::from("bug-pattern")];
+    let episode_ids = [ep.clone()];
+
+    // (1) Grounded, ≥3 words, known concept → stored with the gate-computed
+    // confidence (never a client hint), returning the new node id.
+    let stored = commit_gated_fact(
+        &mem,
+        "bug-pattern",
+        "empty outcome list panics cycle",
+        true,
+        &source,
+        &tags,
+        &episode_ids,
+    )
+    .expect("commit must not error");
+    let FactGateDecision::Stored {
+        confidence,
+        node_id,
+    } = stored.clone()
+    else {
+        panic!("expected Stored, got {stored:?}");
+    };
+    assert!(stored.stored());
+    assert!(confidence >= RELIABILITY_THRESHOLD);
+    assert!(!node_id.is_empty());
+
+    // (2) Identical fact again → dedup quarantine; its score still clears the
+    // threshold, so a caller can tell it apart from a low-reliability block.
+    let dup = commit_gated_fact(
+        &mem,
+        "bug-pattern",
+        "empty outcome list panics cycle",
+        true,
+        &source,
+        &tags,
+        &episode_ids,
+    )
+    .expect("commit must not error");
+    assert!(!dup.stored());
+    assert!(
+        dup.confidence() >= RELIABILITY_THRESHOLD,
+        "a dedup quarantine cleared the threshold; only the prior blocks it"
+    );
+
+    // (3) Ungrounded empty fact → low-reliability quarantine (score below the
+    // threshold), nothing written.
+    let blocked = commit_gated_fact(
+        &mem,
+        "bug-pattern",
+        "   ",
+        false,
+        &source,
+        &tags,
+        &episode_ids,
+    )
+    .expect("commit must not error");
+    assert!(!blocked.stored());
+    assert!(
+        blocked.confidence() < RELIABILITY_THRESHOLD,
+        "an ungrounded empty fact scores below the threshold"
+    );
+}
diff --git a/src/lib.rs b/src/lib.rs
index cb72d651..bc462569 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -59,8 +59,14 @@ pub mod disk_pressure;
 pub mod engineer_loop;
 pub mod engineer_worktree;
 pub mod error;
+// Issue #2679: the shared per-fact reliability scorer, homed here so both
+// write-boundary seams (the IPC `StoreFactGated` handler and the in-process
+// distill sink) apply the identical store/quarantine decision.
 pub mod eval_watchdog;
 pub mod evidence;
+pub mod fact_reliability;
+#[cfg(test)]
+mod fact_reliability_tests;
 pub mod git_guardrails;
 pub mod goal_board_store;
 pub mod goal_curation;
diff --git a/src/memory_consolidation/distillation.rs b/src/memory_consolidation/distillation.rs
index 9f5cf8b4..74277175 100644
--- a/src/memory_consolidation/distillation.rs
+++ b/src/memory_consolidation/distillation.rs
@@ -1,30 +1,36 @@
 //! Episode distillation: extract semantic facts from batches of recent
-//! episodes via an LLM recipe.
+//! episodes via an LLM recipe, with the distiller now a **true agentic step**
+//! whose writes ARE its output (issue #2679).
 //!
-//! See `docs/architecture/episode-distillation.md` for the full design
-//! (issue #2281, PR-B). This module:
+//! See `docs/architecture/distillation-semantic-handoff.md` for the full design.
+//! This module:
 //!
 //! 1. Pulls up to [`DISTILL_BATCH_SIZE`] undistilled episodes from the
 //!    cognitive-memory backend, newest first.
-//! 2. If fewer than [`DISTILL_MIN_EPISODES`] are present, skips the
-//!    pass entirely — no LLM call, no markers.
-//! 3. Otherwise invokes a pluggable [`DistillRecipeRunner`] that
-//!    classifies each episode into one of three concept labels
-//!    (`pr-pattern`, `bug-pattern`, `lesson-learned`) or `skip`. Surface-form
-//!    variants of those labels (case, whitespace, `_`↔`-`) are canonicalized by
-//!    [`canonical_distill_concept`] so a well-formed fact is not lost to
-//!    cosmetics; genuinely off-spec labels are still dropped.
-//! 4. Self-assesses each candidate fact's reliability (issue #2433,
-//!    BGML's ISAO) and GATES on `Fact.confidence`: low-reliability facts
-//!    are quarantined (not promoted) and a weaker new fact never clobbers
-//!    a stronger existing fact on the same concept. Surviving facts are
-//!    stored via `store_fact_with_provenance` with the *computed*
-//!    confidence rather than a constant.
-//! 5. Marks EVERY input episode (including those classified `skip`) as
-//!    distilled so the same low-value batch is not re-fed to the LLM.
+//! 2. If fewer than [`DISTILL_MIN_EPISODES`] are present, skips the pass
+//!    entirely — no LLM call, no markers.
+//! 3. Otherwise invokes a pluggable [`DistillRecipeRunner`] as an **agentic**
+//!    step ([`DistillRecipeRunner::run_agentic`]). The distiller commits each
+//!    derived fact DIRECTLY through the cognitive-memory write boundary — for the
+//!    real subprocess runner that is the agent calling `simard memory remember`
+//!    per fact; for the deterministic test stubs it is the in-process
+//!    [`DistillFactSink`] bridging the stub's returned facts. **There is no
+//!    `{ "facts": [...] }` document scraped back out of recipe stdout and
+//!    hand-deserialized** — the trailing-comma / noisy-banner parse-failure mode
+//!    of #2658/#2679 is therefore structurally impossible: there is nothing left
+//!    to parse.
+//! 4. The write boundary self-assesses each candidate fact's reliability (issue
+//!    #2433, BGML's ISAO) via the shared [`crate::fact_reliability`] scorer and
+//!    GATES on it: low-reliability facts are quarantined (not promoted) and a
+//!    weaker new fact never clobbers a stronger existing fact of the same
+//!    identity. Surviving facts are stored via `store_fact_with_provenance` with
+//!    the *computed* confidence.
+//! 5. Marks EVERY input episode (including those classified `skip`) as distilled
+//!    so the same low-value batch is not re-fed to the LLM.
 //!
-//! On recipe error: NO facts are stored AND NO markers are set; the
-//! batch is fully eligible for retry on the next pass.
+//! On recipe error (a non-zero recipe exit — the ONLY failure the result path
+//! can report now): NO markers are set; the batch is fully eligible for retry on
+//! the next pass.
 
 use std::path::Path;
 use std::process::Command;
@@ -32,125 +38,198 @@ use std::process::Command;
 use crate::cognitive_memory::CognitiveMemoryOps;
 use crate::error::{SimardError, SimardResult};
 use crate::memory_cognitive::CognitiveEpisode;
-use crate::memory_consolidation::raw_capture;
 
 /// Maximum number of episodes pulled per distillation pass.
 pub const DISTILL_BATCH_SIZE: u32 = 50;
 
-/// Minimum number of undistilled episodes that must be present for a
-/// pass to fire. Below this, the pass is a no-op (no LLM call, no
-/// markers). Distillation is many-to-few; running it on a handful of
-/// episodes wastes an LLM call for little quality gain.
+/// Minimum number of undistilled episodes that must be present for a pass to
+/// fire. Below this, the pass is a no-op (no LLM call, no markers).
 pub const DISTILL_MIN_EPISODES: u32 = 20;
 
-/// Legacy per-fact confidence baseline. Before issue #2433 every distilled
-/// fact was written with this exact constant, so `Fact.confidence` carried no
-/// information. It is retained as the **nominal baseline**: a fully-grounded,
-/// known-concept, well-formed fact scores at or above this value under
-/// [`assess_fact_reliability`], preserving downstream filtering behaviour for
-/// good facts while letting weak ones drop below the gate.
+/// Legacy per-fact confidence baseline. Retained as the **nominal baseline**: a
+/// fully-grounded, known-concept, well-formed fact scores at or above this value
+/// under the shared reliability scorer.
 pub const DISTILL_FACT_CONFIDENCE: f64 = 0.7;
 
-/// ISAO reliability gate threshold (issue #2433). Candidate facts whose
-/// self-assessed reliability score is below this are **quarantined** — not
-/// promoted into semantic memory — rather than written with a blind constant
-/// confidence. Tuned so a fact with valid in-batch provenance, a known
-/// concept label, and non-trivial content clears the bar, while a fact with
-/// hallucinated provenance or empty content does not.
-pub const DISTILL_RELIABILITY_THRESHOLD: f64 = 0.5;
+/// ISAO reliability gate threshold (issue #2433). Re-exported from the shared
+/// [`crate::fact_reliability`] module — the single source of truth homing the
+/// gate at the write boundary (issue #2679).
+pub const DISTILL_RELIABILITY_THRESHOLD: f64 = crate::fact_reliability::RELIABILITY_THRESHOLD;
 
 /// The closed concept-label set the distillation recipe is constrained to.
-/// A fact whose concept is outside this set is off-spec and loses the
-/// concept-validity component of its reliability score.
-pub const KNOWN_DISTILL_CONCEPTS: &[&str] = &["pr-pattern", "bug-pattern", "lesson-learned"];
+/// Re-exported from [`crate::fact_reliability`].
+pub const KNOWN_DISTILL_CONCEPTS: &[&str] = crate::fact_reliability::KNOWN_CONCEPTS;
 
-/// Maximum number of *in-cycle* retries of the distill recipe on a **transient**
-/// failure (issue #2468). The pass makes at most `DISTILL_PARSE_RETRY_MAX + 1`
-/// runner invocations: one initial attempt plus this many retries.
-///
-/// A transient miss — the recipe exited `0` but its step output carried no
-/// parseable `{ "facts": [...] }` object ([`DistillFailureClass::ParseFailure`]),
-/// or the recipe process exited non-zero
-/// ([`DistillFailureClass::CopilotTerminalFailure`]) — previously deferred the
-/// whole batch for a full consolidation cycle. A single bounded retry, with
-/// JSON-format reinforcement threaded into the recipe (see
-/// [`DistillRecipeRunner::run_all_reinforced`]), recovers most of these within
-/// the same pass, turning a dropped batch into stored facts. Structural classes
-/// (`SpawnFailure`, `SerializeFailure`, and `Other`) are NOT retried
-/// — they escalate immediately. Kept at `1` so the recovery stays bounded and a
-/// genuinely broken recipe still surfaces promptly.
-pub const DISTILL_PARSE_RETRY_MAX: u32 = 1;
-
-/// A single semantic fact emitted by the recipe runner for one batch
-/// of episodes.
+/// A single semantic fact emitted by the recipe runner for one batch of
+/// episodes.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DistilledFact {
-    /// One of `pr-pattern`, `bug-pattern`, `lesson-learned`. The
-    /// recipe is constrained to this label set by its prompt.
+    /// One of `pr-pattern`, `bug-pattern`, `lesson-learned`. The recipe is
+    /// constrained to this label set by its prompt.
     pub concept: String,
-    /// Free-text content of the fact. Stored verbatim via `store_fact`.
+    /// Free-text content of the fact. Stored verbatim.
     pub content: String,
-    /// `node_id` of the source episode (used to compose the
-    /// `source_id` of the resulting fact as `distill:{id}` for
-    /// provenance).
+    /// `node_id` of the source episode (used to compose the `source_id` of the
+    /// resulting fact as `distill:{id}` for provenance).
     pub source_episode_id: String,
 }
 
-/// A recurring action sequence distilled from a batch of episodes
-/// (issue #2327, R5). Stored via `store_procedure_with_provenance` so a
-/// `PROCEDURE_DERIVES_FROM` edge links the procedure back to the episodes it
-/// was distilled from.
+/// A recurring action sequence distilled from a batch of episodes (issue #2327,
+/// R5). Stored via `store_procedure_with_provenance` so a
+/// `PROCEDURE_DERIVES_FROM` edge links the procedure back to its episodes.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DistilledProcedure {
     /// Procedure name (e.g. `ci-fix:auto`). Upsert-by-name on store.
     pub name: String,
     /// Ordered steps of the procedure.
     pub steps: Vec<String>,
-    /// `node_id`s of the episodes this procedure was distilled from
-    /// (threaded as provenance).
+    /// `node_id`s of the episodes this procedure was distilled from (threaded as
+    /// provenance).
     pub source_episode_ids: Vec<String>,
 }
 
-/// The full output of one distillation pass: facts AND procedures
-/// (issue #2327, R5). Additive over the legacy fact-only shape — a
-/// fact-only runner yields an empty `procedures` vector.
+/// The full output of one distillation pass: facts AND procedures (issue #2327,
+/// R5). Additive over the legacy fact-only shape — a fact-only runner yields an
+/// empty `procedures` vector.
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct DistillOutput {
     pub facts: Vec<DistilledFact>,
     pub procedures: Vec<DistilledProcedure>,
 }
 
-/// Outcome of a single **capturing** runner invocation
-/// ([`DistillRecipeRunner::run_all_reinforced_capturing`]): the parse result
-/// plus, on a failure that produced recipe stdout, the raw pre-extraction bytes
-/// so the caller can harvest a real currently-failing sample (Wave 1
-/// raw-capture, 2026-07-02 operator-review priority 1).
-pub struct DistillAttemptOutcome {
-    /// The parse result — identical to what [`run_all_reinforced`] returns.
-    ///
-    /// [`run_all_reinforced`]: DistillRecipeRunner::run_all_reinforced
-    pub result: SimardResult<DistillOutput>,
-    /// The raw recipe stdout **exactly as the extractor received it**, present
-    /// only when the runner actually produced stdout AND parsing failed. `None`
-    /// for stub runners with no stdout and for spawn/terminal failures (which
-    /// never yielded a parseable step output to harvest).
-    pub raw_on_failure: Option<String>,
+// ───────────────────────────────────────────────────────────────────────────
+// Write-boundary sink (issue #2679): the in-process seam that applies the SAME
+// reliability gate as the IPC server's `StoreFactGated` handler.
+// ───────────────────────────────────────────────────────────────────────────
+
+/// The write boundary a distilled fact/procedure is committed through.
+///
+/// Post-#2679 the distiller no longer returns a document Simard parses; it
+/// *commits* each record. Two seams implement this trait: the real subprocess
+/// runner delegates to the daemon's IPC gate (the agent calls
+/// `simard memory remember`), and the deterministic test stubs are bridged to
+/// the in-process [`InProcessFactSink`], which applies the identical shared
+/// [`crate::fact_reliability`] gate so a fact stores/quarantines the same way no
+/// matter which boundary writes it.
+pub trait DistillFactSink {
+    /// Ground, score, gate, dedup, and (if it survives) persist one fact.
+    /// Returns `true` when the fact was STORED, `false` when it was quarantined
+    /// (low reliability or an equal-or-stronger prior already exists).
+    fn commit_fact(&mut self, fact: &DistilledFact) -> SimardResult<bool>;
+
+    /// Persist one procedure with its source-episode provenance.
+    fn commit_procedure(&mut self, procedure: &DistilledProcedure) -> SimardResult<()>;
+}
+
+/// Per-pass tally of what the write boundary accepted (issue #2679), returned by
+/// [`DistillRecipeRunner::run_agentic`] so the pass report and telemetry reflect
+/// the gate's decisions even on the real agentic path (where the facts are
+/// written by the agent through the daemon, not by the in-process sink).
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct DistillCommit {
+    /// Facts the gate accepted and stored.
+    pub facts: u32,
+    /// Facts the gate quarantined (low reliability or dedup skip).
+    pub quarantined: u32,
+    /// Procedures stored.
+    pub procedures: u32,
+}
+
+/// In-process implementation of [`DistillFactSink`] used by the deterministic
+/// test stubs (and any run-only runner bridged through the default
+/// [`DistillRecipeRunner::run_agentic`]). Grounds a fact by **batch membership**
+/// — the store-existence check the IPC server does has no meaning in-process, so
+/// the batch it was distilled from is the ground truth — then applies the shared
+/// reliability gate, so its store/quarantine decision matches the server seam.
+struct InProcessFactSink<'a> {
+    memory: &'a dyn CognitiveMemoryOps,
+    /// Node ids of the batch's episodes, precomputed once so per-fact grounding
+    /// is an O(1) set lookup rather than an O(batch) scan for every fact.
+    episode_ids: std::collections::HashSet<&'a str>,
+}
+
+impl<'a> InProcessFactSink<'a> {
+    fn new(memory: &'a dyn CognitiveMemoryOps, batch: &'a [CognitiveEpisode]) -> Self {
+        let episode_ids = batch.iter().map(|e| e.node_id.as_str()).collect();
+        Self {
+            memory,
+            episode_ids,
+        }
+    }
+}
+
+impl DistillFactSink for InProcessFactSink<'_> {
+    fn commit_fact(&mut self, fact: &DistilledFact) -> SimardResult<bool> {
+        // Grounding is batch-membership for the in-process seam (O(1) set lookup).
+        let grounded = self.episode_ids.contains(fact.source_episode_id.as_str());
+
+        // Score → threshold → dedup → persist through the single shared gate, so
+        // this in-process seam and the IPC server's `StoreFactGated` handler
+        // decide every fact's disposition identically.
+        let source = format!("distill:{}", fact.source_episode_id);
+        let decision = crate::fact_reliability::commit_gated_fact(
+            self.memory,
+            &fact.concept,
+            &fact.content,
+            grounded,
+            &source,
+            std::slice::from_ref(&fact.concept),
+            std::slice::from_ref(&fact.source_episode_id),
+        )?;
+
+        match decision {
+            crate::fact_reliability::FactGateDecision::Stored { .. } => Ok(true),
+            // A below-threshold score and a dedup skip are BOTH quarantines; the
+            // confidence tells them apart (a dedup skip cleared the threshold).
+            crate::fact_reliability::FactGateDecision::Quarantined { confidence }
+                if confidence < DISTILL_RELIABILITY_THRESHOLD =>
+            {
+                tracing::warn!(
+                    target: "simard::distill",
+                    concept = %fact.concept,
+                    source_episode_id = %fact.source_episode_id,
+                    confidence,
+                    threshold = DISTILL_RELIABILITY_THRESHOLD,
+                    "distill: quarantined low-reliability fact (below threshold), not promoted"
+                );
+                Ok(false)
+            }
+            crate::fact_reliability::FactGateDecision::Quarantined { confidence } => {
+                tracing::info!(
+                    target: "simard::distill",
+                    concept = %fact.concept,
+                    confidence,
+                    "distill: an equal-or-stronger copy of this fact already exists; not downgrading prior"
+                );
+                Ok(false)
+            }
+        }
+    }
+
+    fn commit_procedure(&mut self, procedure: &DistilledProcedure) -> SimardResult<()> {
+        self.memory.store_procedure_with_provenance(
+            &procedure.name,
+            &procedure.steps,
+            &[],
+            &procedure.source_episode_ids,
+        )?;
+        Ok(())
+    }
 }
 
 /// Pluggable LLM-side runner for the distillation recipe.
 ///
-/// The trait exists so tests can substitute a deterministic stub.
-/// Production code uses [`RecipeRunnerSubprocess`] which shells out
-/// to `recipe-runner-rs`.
+/// The trait exists so tests can substitute a deterministic stub. Production
+/// code uses [`RecipeRunnerSubprocess`] which shells out to `recipe-runner-rs`.
 pub trait DistillRecipeRunner {
-    /// Legacy fact-only entry point. Required so existing fact-only
-    /// runners (and the subprocess runner's parse) keep working.
+    /// Legacy fact-only entry point. Required so existing fact-only runners (and
+    /// the test stubs) keep working — the default [`run_agentic`](Self::run_agentic)
+    /// bridges the facts they return into the in-process sink.
     fn run(&self, episodes: &[CognitiveEpisode]) -> SimardResult<Vec<DistilledFact>>;
 
-    /// Full entry point emitting BOTH facts and procedures (issue #2327,
-    /// R5). The default wraps [`run`](Self::run) with an empty procedure
-    /// list, so a runner that only implements `run` distils facts exactly
-    /// as before — back-compatible by construction.
+    /// Full entry point emitting BOTH facts and procedures (issue #2327, R5). The
+    /// default wraps [`run`](Self::run) with an empty procedure list, so a
+    /// fact-only runner distils facts exactly as before.
     fn run_all(&self, episodes: &[CognitiveEpisode]) -> SimardResult<DistillOutput> {
         Ok(DistillOutput {
             facts: self.run(episodes)?,
@@ -158,50 +237,37 @@ pub trait DistillRecipeRunner {
         })
     }
 
-    /// Retry-aware entry point used by the bounded in-cycle retry loop (issue
-    /// #2468). Identical to [`run_all`](Self::run_all), but when
-    /// `strict_json = true` the runner is asked to reinforce the response
-    /// format (e.g. by threading a `strict_json_instruction` context var into
-    /// the recipe so the agent replies with ONLY the `{ "facts": [...] }`
-    /// object). This is used on a retry after a transient parse miss.
-    ///
-    /// The default ignores `strict_json` and delegates to
-    /// [`run_all`](Self::run_all), so test stubs and fact-only runners keep
-    /// working unchanged; only [`RecipeRunnerSubprocess`] overrides it to thread
-    /// the reinforcement flag into the subprocess invocation.
-    fn run_all_reinforced(
-        &self,
-        episodes: &[CognitiveEpisode],
-        strict_json: bool,
-    ) -> SimardResult<DistillOutput> {
-        let _ = strict_json;
-        self.run_all(episodes)
-    }
-
-    /// Like [`run_all_reinforced`](Self::run_all_reinforced), but on failure ALSO
-    /// surfaces the raw pre-extraction recipe stdout so the caller can harvest a
-    /// real currently-failing sample (Wave 1 raw-capture).
-    ///
-    /// The default delegates to [`run_all_reinforced`](Self::run_all_reinforced)
-    /// and supplies no raw (`raw_on_failure = None`), so stub/fact-only runners
-    /// keep working unchanged. Only [`RecipeRunnerSubprocess`] overrides it to
-    /// thread the full stdout through — it is the only runner that HAS the bytes
-    /// the diagnostic exists to capture.
+    /// Agentic entry point (issue #2679): the runner performs its distillation
+    /// and commits each resulting fact/procedure through `sink` — the write
+    /// boundary — rather than returning a document Simard must parse.
     ///
-    /// NOTE for future runners: `run_all_reinforced` and this method must not be
-    /// left to delegate to *each other*. `RecipeRunnerSubprocess` overrides BOTH
-    /// (its `run_all_reinforced` calls this method, which does the real work). A
-    /// runner that overrides ONLY `run_all_reinforced` to call back into this
-    /// default would recurse infinitely — override both, or neither.
-    fn run_all_reinforced_capturing(
+    /// The **default** bridges a run-only stub's returned facts/procedures into
+    /// the in-process [`InProcessFactSink`], so a stub that implements only
+    /// [`run`](Self::run) (or [`run_all`](Self::run_all)) keeps working unchanged
+    /// — the additive-trait contract. [`RecipeRunnerSubprocess`] **overrides**
+    /// this: the distiller agent writes each fact DIRECTLY through the memory
+    /// tool during the recipe run, so there is no returned document and nothing
+    /// for the sink to receive; the override only interprets the recipe's exit
+    /// status.
+    fn run_agentic(
         &self,
         episodes: &[CognitiveEpisode],
-        strict_json: bool,
-    ) -> DistillAttemptOutcome {
-        DistillAttemptOutcome {
-            result: self.run_all_reinforced(episodes, strict_json),
-            raw_on_failure: None,
+        sink: &mut dyn DistillFactSink,
+    ) -> SimardResult<DistillCommit> {
+        let DistillOutput { facts, procedures } = self.run_all(episodes)?;
+        let mut commit = DistillCommit::default();
+        for fact in &facts {
+            if sink.commit_fact(fact)? {
+                commit.facts += 1;
+            } else {
+                commit.quarantined += 1;
+            }
+        }
+        for procedure in &procedures {
+            sink.commit_procedure(procedure)?;
+            commit.procedures += 1;
         }
+        Ok(commit)
     }
 }
 
@@ -209,27 +275,24 @@ pub trait DistillRecipeRunner {
 ///
 /// Two terminal shapes:
 ///
-/// - **Skipped**: `input_count == fact_count == marked_count == 0`
-///   (under threshold). Use [`DistillReport::skipped`] / `was_skipped`.
-/// - **Ran**: `input_count >= DISTILL_MIN_EPISODES`. `fact_count`
-///   is the number of `store_fact` calls; `marked_count` is the number
-///   of `mark_episode_distilled` calls (equal to `input_count` on
-///   success, `0` on recipe error).
+/// - **Skipped**: all counts zero (under threshold). Use
+///   [`DistillReport::skipped`] / [`was_skipped`](DistillReport::was_skipped).
+/// - **Ran**: `input_count >= DISTILL_MIN_EPISODES`. `fact_count` is the number
+///   of facts committed through the in-process sink; `marked_count` is the number
+///   of episodes marked distilled (equal to `input_count` on success).
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct DistillReport {
     /// Number of undistilled episodes pulled from the store.
     pub input_count: u32,
-    /// Number of facts emitted by the recipe.
+    /// Number of facts committed to semantic memory.
     pub fact_count: u32,
-    /// Number of procedures emitted by the recipe (issue #2327, R5).
+    /// Number of procedures committed (issue #2327, R5).
     pub procedure_count: u32,
     /// Number of episodes marked distilled after the pass.
     pub marked_count: u32,
-    /// Number of candidate facts blocked by the ISAO reliability gate
-    /// (issue #2433): quarantined for low self-assessed reliability OR
-    /// skipped to avoid clobbering a higher-confidence existing fact.
-    /// `fact_count + quarantined_count` is the total candidate count the
-    /// recipe emitted for this pass.
+    /// Number of candidate facts blocked by the ISAO reliability gate (issue
+    /// #2433): quarantined for low self-assessed reliability OR skipped to avoid
+    /// clobbering a higher-confidence existing fact.
     pub quarantined_count: u32,
 }
 
@@ -239,7 +302,7 @@ impl DistillReport {
         Self::default()
     }
 
-    /// `true` when the pass did not fire (input/output/marks all zero).
+    /// `true` when the pass did not fire (all counts zero).
     pub fn was_skipped(&self) -> bool {
         self.input_count == 0
             && self.fact_count == 0
@@ -248,10 +311,8 @@ impl DistillReport {
             && self.quarantined_count == 0
     }
 
-    /// Reduction ratio (`1 - fact_count / input_count`) as a fraction
-    /// in `[0.0, 1.0]`. Returns `0.0` when `input_count == 0` (the
-    /// skipped case) to avoid a divide-by-zero in the observability
-    /// log line.
+    /// Reduction ratio (`1 - fact_count / input_count`) in `[0.0, 1.0]`. Returns
+    /// `0.0` when `input_count == 0`.
     pub fn reduction(&self) -> f64 {
         if self.input_count == 0 {
             0.0
@@ -266,14 +327,14 @@ impl DistillReport {
 /// This is the testable entry point. Production code calls
 /// [`distill_recent_episodes`] which wraps the subprocess runner.
 ///
-/// Contract (see `docs/architecture/episode-distillation.md`):
+/// Contract (see `docs/architecture/distillation-semantic-handoff.md`):
 ///
-/// - Under threshold → returns `Ok(DistillReport::skipped())`; runner
-///   is NOT invoked; no markers set; no facts stored.
-/// - Above threshold + recipe success → all input episodes are marked
-///   distilled (even when the recipe yielded zero facts).
-/// - Above threshold + recipe error → returns `Err(...)`; no markers
-///   set; no facts stored.
+/// - Under threshold → returns `Ok(DistillReport::skipped())`; runner is NOT
+///   invoked; no markers set; no facts stored.
+/// - Above threshold + recipe success → the agentic step's facts have been
+///   committed and all input episodes are marked distilled.
+/// - Above threshold + recipe error → returns `Err(...)`; no markers set (the
+///   batch stays fully retry-eligible on the next pass).
 #[tracing::instrument(skip_all)]
 pub fn distill_recent_episodes_with_runner(
     memory: &dyn CognitiveMemoryOps,
@@ -289,9 +350,6 @@ pub fn distill_recent_episodes_with_runner(
             min = DISTILL_MIN_EPISODES,
             "distill: {pulled} episodes pulled, below min {DISTILL_MIN_EPISODES}, skipped"
         );
-        eprintln!(
-            "[simard] distill: {pulled} episodes pulled, below min {DISTILL_MIN_EPISODES}, skipped"
-        );
         return Ok(DistillReport::skipped());
     }
 
@@ -302,223 +360,44 @@ pub fn distill_recent_episodes_with_runner(
         min = DISTILL_MIN_EPISODES,
         "distill: {pulled} episodes pulled (batch size {DISTILL_BATCH_SIZE}, min {DISTILL_MIN_EPISODES})"
     );
-    eprintln!(
-        "[simard] distill: {pulled} episodes pulled (batch size {DISTILL_BATCH_SIZE}, min {DISTILL_MIN_EPISODES})"
-    );
 
-    // Run the recipe with a bounded in-cycle retry on TRANSIENT failures only
-    // (issue #2468). A transient miss — the recipe exited 0 but its step output
-    // had no parseable `{ "facts": [...] }` object (`ParseFailure`), or the
-    // recipe process exited non-zero (`CopilotTerminalFailure`) — previously
-    // deferred the whole batch for a full consolidation cycle. We retry up to
-    // `DISTILL_PARSE_RETRY_MAX` times within THIS pass, threading JSON-format
-    // reinforcement into the retry (`strict_json = true`). Structural classes
-    // (spawn/serialize/recipe-reported failure, and `Other`) are deterministic
-    // and escalate immediately — retrying them only wastes an LLM call.
-    //
-    // The retry-safety invariant is preserved across every attempt: no episode
-    // is marked and no fact is stored until an attempt finally parses. On final
-    // failure we return `Err` WITHOUT marking, so the batch stays fully
-    // retry-eligible on the next pass (the invariant under test in
-    // `distillation_handles_recipe_error_without_marking`).
-    let mut attempt: u32 = 0;
-    let output = loop {
-        attempt += 1;
-        // Reinforce the response format on any attempt past the first.
-        let strict_json = attempt > 1;
-        let DistillAttemptOutcome {
-            result,
-            raw_on_failure,
-        } = runner.run_all_reinforced_capturing(&episodes, strict_json);
-        match result {
-            Ok(o) => break o,
-            Err(e) => {
-                let class = classify_distill_error(&e);
-                let retries_left = attempt <= DISTILL_PARSE_RETRY_MAX;
-                if class.is_transient() && retries_left {
-                    tracing::warn!(
-                        target: "simard::distill",
-                        pulled,
-                        attempt,
-                        class = class.as_str(),
-                        error = %e,
-                        "distill: transient failure, retrying in-cycle with format reinforcement"
-                    );
-                    eprintln!(
-                        "[simard] distill: transient {} on attempt {attempt}, retrying in-cycle (strict json)",
-                        class.as_str()
-                    );
-                    continue;
-                }
-                tracing::warn!(
-                    target: "simard::distill",
-                    pulled,
-                    attempt,
-                    class = class.as_str(),
-                    error = %e,
-                    "distill: {pulled} episodes pulled, recipe error, no markers set, retry next pass"
-                );
-                eprintln!(
-                    "[simard] distill: {pulled} episodes pulled, recipe error: {e}, no markers set, retry next pass"
-                );
-                // Make the previously-silent non-fatal failure visible (#2461).
-                // Recorded BEFORE the early return; episodes stay unmarked, so
-                // the retry-safety invariant is unaffected. `attempt` lets the
-                // metric distinguish a first-attempt failure from an exhausted
-                // retry; a failed pass never "recovered".
-                record_distill_success_metric(false, Some(class), pulled, 0, attempt, false);
-                // Issue #2528: mirror the distill failure into the unified
-                // telemetry facade alongside the human log lines above, so the
-                // status snapshot's distill-fail rate is a structured signal
-                // rather than a journald grep.
-                crate::telemetry::counter_add(
-                    crate::telemetry::names::DISTILL_RUNS,
-                    1,
-                    &[(crate::telemetry::names::ATTR_RESULT, "parse_fail")],
-                );
-                // Wave 1 (2026-07-02 operator-review priority 1): env-gated,
-                // default-off raw-capture of a SURVIVING parse failure so a real
-                // currently-failing sample can be harvested into a regression
-                // test. `capture_parse_failure` self-gates to the toggle AND to
-                // `failure_class == "parse-failure"`, so calling it on every
-                // escalation is safe — a spawn/terminal/serialize failure writes
-                // nothing. When the runner surfaced the raw stdout we capture it
-                // verbatim ("exactly as the extractor received it"); otherwise
-                // (stub runners with no stdout) we fall back to the classified
-                // error string. Best-effort: a capture error never escalates.
-                let cfg = raw_capture::RawCaptureConfig::from_env();
-                let raw_for_capture = raw_on_failure.unwrap_or_else(|| e.to_string());
-                let meta = raw_capture::CaptureMeta {
-                    failure_class: class.as_str(),
-                    recipe_exited_ok: class.recipe_exited_ok(),
-                    attempt,
-                    recovered_after_retry: false,
-                    input_count: pulled,
-                    fact_count: 0,
-                };
-                let _ = raw_capture::capture_parse_failure(&cfg, &meta, &raw_for_capture);
-                return Err(e);
-            }
-        }
-    };
-    let recovered_after_retry = attempt > 1;
-    let DistillOutput { facts, procedures } = output;
-
-    // ISAO-style reliability gate (issue #2433, BGML §IV). Before promoting a
-    // distilled fact into semantic memory we SELF-ASSESS its reliability and
-    // gate on `Fact.confidence` instead of writing a blind constant:
-    //   * low-reliability candidates are QUARANTINED (not stored) so they can
-    //     never corrupt the integrity of past experience, and
-    //   * a weaker new fact never CLOBBERS a higher-confidence existing fact on
-    //     the same concept (mirrors the cross-session dedup guard in
-    //     `memory_consolidation::mod`).
-    // Surviving facts are written with the *computed* confidence, turning the
-    // formerly-dormant `confidence` column into a live consolidation→recall
-    // signal. The originating episode id is still threaded through as
-    // provenance (`source_episode_ids`) for the DERIVES_FROM edge (issue #2325).
-    let mut stored = 0u32;
-    let mut quarantined = 0u32;
-    for fact in &facts {
-        let confidence = assess_fact_reliability(fact, &episodes, &facts);
-
-        if confidence < DISTILL_RELIABILITY_THRESHOLD {
-            quarantined += 1;
+    // Run the distiller as an agentic step. It commits its facts/procedures
+    // through the sink (in-process stubs) or the memory tool (real subprocess).
+    // Retry-safety invariant: on failure NO episode is marked, so the batch
+    // stays fully retry-eligible next pass.
+    let mut sink = InProcessFactSink::new(memory, &episodes);
+    let commit = match runner.run_agentic(&episodes, &mut sink) {
+        Ok(commit) => commit,
+        Err(e) => {
+            let class = classify_distill_error(&e);
             tracing::warn!(
                 target: "simard::distill",
-                concept = %fact.concept,
-                source_episode_id = %fact.source_episode_id,
-                confidence,
-                threshold = DISTILL_RELIABILITY_THRESHOLD,
-                "distill: quarantined low-reliability fact (below threshold), not promoted"
-            );
-            eprintln!(
-                "[simard] distill: quarantined low-reliability fact concept={} confidence={:.2} < {:.2}",
-                fact.concept, confidence, DISTILL_RELIABILITY_THRESHOLD
+                pulled,
+                class = class.as_str(),
+                error = %e,
+                "distill: {pulled} episodes pulled, recipe error, no markers set, retry next pass"
             );
-            continue;
-        }
-
-        // Protect past experience: do not let a weaker new fact supersede a
-        // stronger existing *version of the same fact* (BGML ISAO integrity).
-        //
-        // The match is on fact IDENTITY (concept + content), NOT the concept
-        // label alone. The distillation recipe emits at most three concept
-        // labels (`pr-pattern` / `bug-pattern` / `lesson-learned`) and every
-        // grounded, well-formed fact scores identically, so a concept-only
-        // guard would treat each distilled fact as a duplicate of the first one
-        // stored under that label and quarantine every subsequent DISTINCT fact
-        // — silently neutering distillation after the first pass (issue #2433).
-        // Identity matching instead blocks only a genuine re-distillation of the
-        // *same* content at a lower-or-equal confidence, while letting distinct
-        // lessons that happen to share a label accumulate.
-        //
-        // `search_facts` is queried with the new confidence as `min_confidence`,
-        // so it returns only priors strong enough to block; production
-        // `search_facts` matches the concept label against the same live graph
-        // these writes target, so an in-pass sibling is visible here too. The
-        // explicit `>=` comparison is belt-and-suspenders against a backend that
-        // ignores the `min_confidence` filter.
-        let existing = memory
-            .search_facts(&fact.concept, 5, confidence)
-            .unwrap_or_default();
-        let new_content = fact.content.trim();
-        if existing
-            .iter()
-            .any(|f| f.content.trim() == new_content && f.confidence >= confidence)
-        {
-            quarantined += 1;
-            tracing::info!(
-                target: "simard::distill",
-                concept = %fact.concept,
-                confidence,
-                "distill: an equal-or-stronger copy of this fact already exists; not downgrading prior"
-            );
-            eprintln!(
-                "[simard] distill: kept stronger prior for concept={} (new confidence={:.2} would downgrade an identical fact)",
-                fact.concept, confidence
-            );
-            continue;
+            record_distill_success_metric(false, Some(class), pulled, 0);
+            // NOTE (#2679): a failed pass is surfaced via `distill_success_rate`
+            // (value 0.0) above and by propagating `Err`. We deliberately do NOT
+            // emit a `simard.distill.runs` counter on failure: that counter now
+            // tracks only completed agentic commits (`result="ok"`), and the
+            // `parse_fail` result it used to carry no longer exists because there
+            // is no parse to fail.
+            return Err(e);
         }
+    };
 
-        let source = format!("distill:{}", fact.source_episode_id);
-        memory.store_fact_with_provenance(
-            &fact.concept,
-            &fact.content,
-            confidence,
-            &source,
-            Some(std::slice::from_ref(&fact.concept)),
-            None,
-            std::slice::from_ref(&fact.source_episode_id),
-        )?;
-        stored += 1;
-    }
+    let stored = commit.facts;
+    let quarantined = commit.quarantined;
+    let stored_procs = commit.procedures;
 
-    // Before/after measurement of the gate's block-rate (issue #2433
-    // acceptance). Best-effort, no-op under `cfg!(test)` so unit tests never
-    // append to the operator's real metrics file.
-    record_reliability_gate_metric(facts.len() as u32, quarantined, stored);
-
-    // Store every procedure via the provenance write path (issue #2327, R5).
-    // `source_episode_ids` are threaded so a `PROCEDURE_DERIVES_FROM` edge links
-    // the procedure back to the recurring episodes it was distilled from. The
-    // upsert-by-name in the backend reinforces an existing procedure rather than
-    // duplicating it (#2298).
-    let mut stored_procs = 0u32;
-    for proc in &procedures {
-        memory.store_procedure_with_provenance(
-            &proc.name,
-            &proc.steps,
-            &[],
-            &proc.source_episode_ids,
-        )?;
-        stored_procs += 1;
-    }
+    // Before/after measurement of the gate's block-rate (issue #2433). Best-
+    // effort, no-op under `cfg!(test)`.
+    record_reliability_gate_metric(stored + quarantined, quarantined, stored);
 
-    // Mark EVERY input episode distilled — even those the recipe
-    // classified `skip` (they contribute no fact but must not be
-    // re-fed to the LLM on the next pass). The mark-everything rule
-    // is the prompt-replay-loop guard documented in
-    // `episode-distillation.md` §"Pipeline overview".
+    // Mark EVERY input episode distilled — even those the recipe classified
+    // `skip`. The mark-everything rule is the prompt-replay-loop guard.
     let mut marked = 0u32;
     for ep in &episodes {
         memory.mark_episode_distilled(&ep.node_id)?;
@@ -535,13 +414,8 @@ pub fn distill_recent_episodes_with_runner(
         reduction_pct,
         "distill: {pulled} episodes → {stored} facts, {stored_procs} procedures, {marked} marked (reduction {reduction_pct:.0}%)"
     );
-    eprintln!(
-        "[simard] distill: {pulled} episodes → {stored} facts, {stored_procs} procedures, {marked} marked"
-    );
 
-    // Issue #2528: mirror the distill outcome into the unified telemetry facade
-    // (OTel counters + in-process registry) ALONGSIDE the human log line above,
-    // so `simard status` reads structured signals instead of grepping journald.
+    // Issue #2528: mirror the distill outcome into the unified telemetry facade.
     crate::telemetry::counter_add(
         crate::telemetry::names::DISTILL_RUNS,
         1,
@@ -563,14 +437,7 @@ pub fn distill_recent_episodes_with_runner(
         &[],
     );
 
-    // The recipe ran and its output parsed (#2461): record a success event so
-    // distill_success_rate / distill_parse_success_rate are measurable. NOTE:
-    // this point is only reached after the storage writes above succeeded; a
-    // downstream memory-write failure propagates as `Err` (a separate subsystem,
-    // out of this recipe-stage metric's scope — see record_distill_success_metric).
-    // `attempt` / `recovered_after_retry` (#2468) let the metric distinguish a
-    // first-attempt success from one recovered by an in-cycle retry.
-    record_distill_success_metric(true, None, pulled, stored, attempt, recovered_after_retry);
+    record_distill_success_metric(true, None, pulled, stored);
 
     Ok(DistillReport {
         input_count: pulled,
@@ -581,119 +448,36 @@ pub fn distill_recent_episodes_with_runner(
     })
 }
 
-/// Self-assess the reliability of one distilled fact (issue #2433, BGML's
-/// *information self-assessment ownership*, §IV). Returns a confidence score in
-/// `[0.0, 1.0]` from cheap, locally-available signals — no extra LLM call:
-///
-/// | Signal | Weight | Rationale |
-/// |--------|--------|-----------|
-/// | **Provenance grounding** | 0.5 | The cited `source_episode_id` must be one of the episodes actually fed to the recipe this pass. A source outside the batch is unverifiable / hallucinated provenance — the strongest unreliability signal. |
-/// | **Content quality** | ≤0.3 | Empty / whitespace-only content carries no information and is a HARD gate (score `0.0`); otherwise ≥3 words earns the full weight. |
-/// | **Concept validity** | 0.1 | The recipe is constrained to [`KNOWN_DISTILL_CONCEPTS`]; an off-set concept means the model went off-spec. |
-/// | **Corroboration** | 0.1 | ≥2 distilled facts agreeing on the same concept this pass — independent agreement across source episodes. Awarded ONLY to grounded facts so hallucinated provenance can't ride on a sibling's corroboration. |
-///
-/// A nominal fact (grounded, ≥3 words, known concept) scores `0.9` — at or
-/// above the legacy [`DISTILL_FACT_CONFIDENCE`] baseline — so good facts keep
-/// their downstream behaviour. Because grounding (0.5) is necessary to clear
-/// [`DISTILL_RELIABILITY_THRESHOLD`] (0.5), a hallucinated-provenance fact tops
-/// out at `0.4` (content + concept) — even WITH corroboration — and an empty
-/// fact scores `0.0`; both are quarantined.
-pub fn assess_fact_reliability(
-    fact: &DistilledFact,
-    episodes: &[CognitiveEpisode],
-    batch_facts: &[DistilledFact],
-) -> f64 {
-    // (0) Hard gate: empty / whitespace-only content carries no information and
-    // is quarantined unconditionally, regardless of how trustworthy its
-    // provenance looks (issue #2433). Without this, a grounded-but-empty fact
-    // (0.5 grounding + 0.1 concept = 0.6) would clear the gate, violating the
-    // documented "empty content is quarantined" invariant.
-    let words = fact.content.split_whitespace().count();
-    if words == 0 {
-        return 0.0;
-    }
-
-    let mut score = 0.0_f64;
-
-    // (1) Provenance grounding — the dominant, *necessary* signal. A source
-    // outside the batch is unverifiable / hallucinated provenance. The weights
-    // below are tuned so that WITHOUT this 0.5 a fact can never reach
-    // `DISTILL_RELIABILITY_THRESHOLD` (0.5): an ungrounded fact tops out at
-    // 0.3 content + 0.1 concept = 0.4 and is always quarantined.
-    let grounded = episodes.iter().any(|e| e.node_id == fact.source_episode_id);
-    if grounded {
-        score += 0.5;
-    }
-
-    // (2) Content quality (content is non-empty here — see the hard gate above).
-    if words >= 3 {
-        score += 0.3;
+/// Block-rate of the reliability gate for one pass: fraction of candidate facts
+/// quarantined. `0.0` when there were no candidates.
+fn gate_block_rate(quarantined: u32, candidate_facts: u32) -> f64 {
+    if candidate_facts == 0 {
+        0.0
     } else {
-        score += 0.15;
-    }
-
-    // (3) Concept validity.
-    let concept = fact.concept.trim();
-    if KNOWN_DISTILL_CONCEPTS
-        .iter()
-        .any(|c| c.eq_ignore_ascii_case(concept))
-    {
-        score += 0.1;
-    }
-
-    // (4) Corroboration: ≥2 facts this pass agreeing on the same concept.
-    // Awarded ONLY to grounded facts — an ungrounded (hallucinated-provenance)
-    // fact must not ride on the corroboration of legitimate same-concept facts
-    // to sneak over the gate (it would otherwise reach 0.3 + 0.1 + 0.1 = 0.5).
-    if grounded {
-        let corroboration = batch_facts
-            .iter()
-            .filter(|f| f.concept.eq_ignore_ascii_case(&fact.concept))
-            .count();
-        if corroboration >= 2 {
-            score += 0.1;
-        }
+        quarantined as f64 / candidate_facts as f64
     }
-
-    score.clamp(0.0, 1.0)
 }
 
 /// Build the JSON `context` payload for the `distill_reliability_gate` metric.
-/// Separated from the I/O so the payload shape is unit-testable without
-/// touching the real `metrics.jsonl`.
 fn build_reliability_gate_context(candidate_facts: u32, quarantined: u32, promoted: u32) -> String {
-    let block_rate = if candidate_facts == 0 {
-        0.0
-    } else {
-        quarantined as f64 / candidate_facts as f64
-    };
     serde_json::json!({
         "candidate_facts": candidate_facts,
         "promoted": promoted,
         "quarantined": quarantined,
-        "block_rate": block_rate,
+        "block_rate": gate_block_rate(quarantined, candidate_facts),
         "threshold": DISTILL_RELIABILITY_THRESHOLD,
     })
     .to_string()
 }
 
-/// Record one `distill_reliability_gate` metric event per distillation pass so
-/// the block-rate (`quarantined / candidate_facts`) is measurable from
-/// `metrics.jsonl` (issue #2433 acceptance: a before/after measurement of the
-/// gate). The metric `value` is the block-rate fraction.
-///
-/// Best-effort: a metrics-write failure is logged, never propagated. No-op
-/// under `cfg!(test)` so unit tests never append to the operator's real
-/// `~/.simard/metrics/metrics.jsonl`.
+/// Record one `distill_reliability_gate` metric event per pass so the block-rate
+/// (`quarantined / candidate_facts`) is measurable. Best-effort; no-op under
+/// `cfg!(test)`.
 fn record_reliability_gate_metric(candidate_facts: u32, quarantined: u32, promoted: u32) {
     if cfg!(test) {
         return;
     }
-    let block_rate = if candidate_facts == 0 {
-        0.0
-    } else {
-        quarantined as f64 / candidate_facts as f64
-    };
+    let block_rate = gate_block_rate(quarantined, candidate_facts);
     let context = build_reliability_gate_context(candidate_facts, quarantined, promoted);
     if let Err(e) =
         crate::self_metrics::record_metric("distill_reliability_gate", block_rate, &context)
@@ -707,38 +491,28 @@ fn record_reliability_gate_metric(candidate_facts: u32, quarantined: u32, promot
 }
 
 // ───────────────────────────────────────────────────────────────────────────
-// distill_success_rate instrumentation (issue #2461)
+// distill_success_rate instrumentation (issue #2461; parse class removed #2679)
 // ───────────────────────────────────────────────────────────────────────────
-//
-// A distillation failure is *non-fatal*: `dispatch_consolidate_memory` folds
-// the `Err` into a human-readable string and still reports the action
-// successful. Without a counter the failure frequency — and therefore the
-// silent degradation of semantic recall — is invisible. We record a
-// `distill_success_rate` metric event per pass that actually ran the recipe so
-// both the success rate and the parse-success rate are measurable from
-// `metrics.jsonl`, mirroring `record_reliability_gate_metric` (#2433).
 
 /// Machine-readable class of a distillation failure, derived from the stable
-/// leading prefix of the `SimardError::RpcError` message emitted at each
-/// runner/parse site in this module. Covers every `Err` `run_all` can surface.
-/// Post-#2622/#2619 the distill result is read from the agent's dedicated facts
-/// file, so a parse failure now manifests as a *missing / empty / unparseable
-/// facts document* rather than a stdout scan miss.
+/// leading prefix of the `SimardError::RpcError` message emitted at each runner
+/// site in this module.
+///
+/// Post-#2679 the distiller writes facts DIRECTLY through the memory tool, so
+/// there is no facts document to parse: the `ParseFailure` class of #2461/#2658
+/// is **gone** — no code path can produce it. The only failure the result path
+/// can now surface is a non-zero recipe exit ([`CopilotTerminalFailure`]) or a
+/// spawn/serialize/other structural failure.
+///
+/// [`CopilotTerminalFailure`]: DistillFailureClass::CopilotTerminalFailure
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum DistillFailureClass {
     /// `recipe-runner-rs` could not be spawned (binary missing/structural), or
-    /// the per-invocation facts output tempdir could not be created.
+    /// the per-invocation episodes tempfile could not be created.
     SpawnFailure,
-    /// The recipe **process** exited non-zero (#2461 t=7411 case).
+    /// The recipe **process** exited non-zero.
     CopilotTerminalFailure,
-    /// The recipe process exited 0 but the agent's facts document was missing,
-    /// empty, or not a parseable `{ "facts": [...] }` object (issues
-    /// #2622/#2619). This is the only failure class that actually *reached* the
-    /// agent output, so it is the denominator gate for
-    /// `distill_parse_success_rate`.
-    ParseFailure,
-    /// The episodes payload failed to serialize (structural; ~unreachable
-    /// since the payload is built from infallible `json!` values).
+    /// The episodes payload failed to serialize (structural; ~unreachable).
     SerializeFailure,
     /// Any other error (e.g. a backend error surfaced through the runner).
     Other,
@@ -750,66 +524,37 @@ impl DistillFailureClass {
         match self {
             Self::SpawnFailure => "spawn-failure",
             Self::CopilotTerminalFailure => "copilot-terminal-failure",
-            Self::ParseFailure => "parse-failure",
             Self::SerializeFailure => "serialize-failure",
             Self::Other => "other",
         }
     }
 
-    /// `true` when the recipe **process** exited 0. False for spawn/terminal
-    /// (never started / non-zero exit) and serialize (never spawned).
-    pub fn recipe_exited_ok(self) -> bool {
-        matches!(self, Self::ParseFailure)
-    }
-
-    /// `true` when the run actually *reached* the agent's facts document (the
-    /// process exited 0 and we tried to read + parse the file). This is the
-    /// denominator gate for `distill_parse_success_rate` — only `ParseFailure`
-    /// qualifies among failures.
-    pub fn reached_parsing(self) -> bool {
-        matches!(self, Self::ParseFailure)
-    }
-
-    /// `true` for failure classes worth a bounded in-cycle retry (issue #2468):
-    /// a parse miss (exited 0, facts document missing/empty/unparseable) or a
-    /// non-zero recipe exit. These are observed to recover on a second attempt —
-    /// often with JSON format reinforcement. Structural classes
+    /// `true` for failure classes worth a bounded in-cycle retry: a non-zero
+    /// recipe exit is observed to recover on a second attempt. Structural classes
     /// (spawn/serialize, and `Other`) are deterministic and escalate immediately.
     pub fn is_transient(self) -> bool {
-        matches!(self, Self::ParseFailure | Self::CopilotTerminalFailure)
+        matches!(self, Self::CopilotTerminalFailure)
     }
 }
 
 /// Classify a distillation `SimardError` into a [`DistillFailureClass`].
 ///
-/// Discrimination anchors on the **stable leading prefix** this module emits
-/// for each class (`SimardError::RpcError(msg)` → `msg.starts_with(...)`),
-/// NOT on `contains`. Several messages embed foreign text (terminal failures
-/// carry up to 200 chars each of recipe stderr/stdout; parse failures carry the
-/// facts-document excerpt), and that variable tail always trails the fixed
-/// prefix — so anchoring keeps a non-zero exit from being misread as a
-/// parse-failure and corrupting `distill_parse_success_rate`.
-///
-/// The prefixes mirror the `RpcError` sites in this file. Post-#2622/#2619 a
-/// parse failure surfaces as a missing / empty / unparseable **facts document**
-/// (the agent's dedicated file), all of which map to `ParseFailure`.
+/// Discrimination anchors on the **stable leading prefix** this module emits for
+/// each class (`SimardError::RpcError(msg)` → `msg.starts_with(...)`), NOT on
+/// `contains`: a terminal failure carries up to 200 chars each of recipe
+/// stderr/stdout, and that variable tail always trails the fixed prefix.
 pub fn classify_distill_error(err: &SimardError) -> DistillFailureClass {
     let SimardError::RpcError(msg) = err else {
         return DistillFailureClass::Other;
     };
     if msg.starts_with("distill: recipe-runner-rs spawn failed")
-        || msg.starts_with("distill: failed to create facts output tempdir")
+        || msg.starts_with("distill: failed to create episodes tempfile")
     {
         DistillFailureClass::SpawnFailure
     } else if msg.starts_with("distill: recipe exited with") {
         DistillFailureClass::CopilotTerminalFailure
     } else if msg.starts_with("distill: failed to serialize episodes payload") {
         DistillFailureClass::SerializeFailure
-    } else if msg.starts_with("distill: facts output file was not written")
-        || msg.starts_with("distill: facts document was empty")
-        || msg.starts_with("distill: facts document did not contain a parseable")
-    {
-        DistillFailureClass::ParseFailure
     } else {
         DistillFailureClass::Other
     }
@@ -817,88 +562,34 @@ pub fn classify_distill_error(err: &SimardError) -> DistillFailureClass {
 
 /// Build the `distill_success_rate` metric context for one pass that ran the
 /// recipe. `class` is `None` on success, `Some(_)` on failure.
-///
-/// `attempt` (1-based) is the number of runner invocations this pass made, and
-/// `recovered_after_retry` is `true` only when a success followed at least one
-/// transient retry (issue #2468) — together they let `distill_parse_success_rate`
-/// distinguish a first-attempt success from one recovered by an in-cycle retry.
 fn build_distill_success_context(
     success: bool,
     class: Option<DistillFailureClass>,
     input_count: u32,
     fact_count: u32,
-    attempt: u32,
-    recovered_after_retry: bool,
 ) -> String {
-    let recipe_exited_ok = success || class.is_some_and(|c| c.recipe_exited_ok());
-    // Parsing was attempted iff a step ran and its output was parsed — true on
-    // success and for a parse-failure, but NOT for a recipe-reported failure
-    // that exited 0 without producing step output.
-    let parse_attempted = success || class.is_some_and(|c| c.reached_parsing());
     serde_json::json!({
         "outcome": if success { "success" } else { "failure" },
-        "recipe_exited_ok": recipe_exited_ok,
-        "parse_attempted": parse_attempted,
-        "parse_success": success,
         "failure_class": class.map(|c| c.as_str()),
         "input_count": input_count,
         "fact_count": fact_count,
-        "attempt": attempt,
-        "recovered_after_retry": recovered_after_retry,
     })
     .to_string()
 }
 
-/// Record the per-pass distill reliability metrics: `distill_success_rate` for
-/// every pass that ran the recipe, plus a first-class `distill_parse_success_rate`
-/// for the subset that reached output parsing (issue #2512).
-///
-/// **Scope: the recipe + output-parse stage** — exactly the failure surface of
-/// issue #2461 (the distill *recipe* exiting non-zero, or exiting 0 with
-/// unparseable output). It is recorded for every pass that ran the recipe
-/// (success OR a recipe/parse failure); below-threshold skips are excluded.
-/// Downstream memory-write failures (`store_fact_with_provenance`,
-/// `store_procedure_with_provenance`, `mark_episode_distilled`) are a *separate*
-/// subsystem and are intentionally NOT folded into this metric: they propagate
-/// as `Err` from `distill_recent_episodes_with_runner` and are surfaced through
-/// the normal error path, so counting them here would conflate backend-write
-/// reliability with recipe reliability. (This mirrors the placement of
-/// `record_reliability_gate_metric`, which likewise covers only the recipe pass.)
-///
-/// The metric `value` is `1.0` on success and `0.0` on a recipe/parse failure,
-/// so the mean over passes is the success rate. `distill_parse_success_rate` is
-/// emitted ONLY for passes that reached parsing (`parse_attempted == true`), so
-/// its plain mean is exactly the parse-success rate — isolating the "exited 0 but
-/// unparseable" mode (#2461 t=7517, plus the #2512 launch-banner-prefixed
-/// envelope) from the "exited non-zero" mode (t=7411), which never reached
-/// parsing and emits no parse-rate event. Both share the same context payload
-/// (`parse_attempted` / `parse_success` flags remain for back-compatible
-/// derivation). This makes the previously-silent non-fatal distill failures
-/// visible in `metrics.jsonl` without committing any point-in-time findings.
-///
-/// Best-effort: a metrics-write failure is logged, never propagated. No-op
-/// under `cfg!(test)` so unit tests never append to the operator's real
-/// `~/.simard/metrics/metrics.jsonl`.
+/// Record the per-pass `distill_success_rate` metric (issue #2461) for every pass
+/// that ran the recipe. Best-effort; no-op under `cfg!(test)`.
 fn record_distill_success_metric(
     success: bool,
     class: Option<DistillFailureClass>,
     input_count: u32,
     fact_count: u32,
-    attempt: u32,
-    recovered_after_retry: bool,
 ) {
     if cfg!(test) {
         return;
     }
     let value = if success { 1.0 } else { 0.0 };
-    let context = build_distill_success_context(
-        success,
-        class,
-        input_count,
-        fact_count,
-        attempt,
-        recovered_after_retry,
-    );
+    let context = build_distill_success_context(success, class, input_count, fact_count);
     if let Err(e) = crate::self_metrics::record_metric("distill_success_rate", value, &context) {
         tracing::warn!(
             target: "simard::distill",
@@ -906,38 +597,13 @@ fn record_distill_success_metric(
             "failed to record distill_success_rate metric (distillation unaffected)",
         );
     }
-
-    // First-class `distill_parse_success_rate` (issue #2512). Previously this
-    // rate was only *derivable* by post-filtering `distill_success_rate` events
-    // on `parse_attempted == true` — fragile and easy to compute wrong. Emit a
-    // dedicated event ONLY for passes that actually reached output parsing
-    // (`parse_attempted`), so the simple mean of `distill_parse_success_rate`
-    // values is exactly the parse-success rate (successes vs. parse attempts).
-    // This is the metric the launch-banner parse fix drives toward 1.0, mirroring
-    // how #2504 was validated for the decide/orient brain. Recipe-reported /
-    // terminal / spawn / serialize failures never reached parsing and are
-    // intentionally excluded from the denominator (they emit no parse-rate event).
-    let parse_attempted = success || class.is_some_and(|c| c.reached_parsing());
-    if parse_attempted
-        && let Err(e) =
-            crate::self_metrics::record_metric("distill_parse_success_rate", value, &context)
-    {
-        tracing::warn!(
-            target: "simard::distill",
-            error = %e,
-            "failed to record distill_parse_success_rate metric (distillation unaffected)",
-        );
-    }
 }
 
-/// Production entry point: run one distillation pass using the
-/// `recipe-runner-rs` subprocess.
+/// Production entry point: run one distillation pass using the `recipe-runner-rs`
+/// subprocess.
 ///
-/// Returns `Ok(DistillReport::skipped())` when the runner cannot be
-/// constructed (e.g. `recipe-runner-rs` not on PATH, no recipe file,
-/// no agent binary). This matches the "skip gracefully" behaviour of
-/// other recipe shims (`RecipeProgressChecker`, `RecipeMergeJudge`)
-/// so distillation never blocks the OODA cycle.
+/// Returns `Ok(DistillReport::skipped())` when the runner cannot be constructed
+/// (e.g. `recipe-runner-rs` not on PATH, no recipe file, no agent binary).
 #[tracing::instrument(skip_all)]
 pub fn distill_recent_episodes(
     memory: &dyn CognitiveMemoryOps,
@@ -957,14 +623,6 @@ pub fn distill_recent_episodes(
 
 const RECIPE_FILENAME: &str = "distill-episodes.yaml";
 
-/// Format-reinforcement sentence threaded into the distill recipe on a retry
-/// after a transient parse miss (issue #2468). Interpolated into the recipe via
-/// the `{{strict_json_instruction}}` substitution; empty on the first attempt.
-const STRICT_JSON_INSTRUCTION: &str = "Your previous attempt did not leave a parseable facts file. Write ONLY the JSON object \
-     {\"facts\":[...]} (and \"procedures\" if any) to the facts file whose path is given above — \
-     no prose, no markdown fence, no thinking, nothing before or after the object, and do \
-     not rely on printing to the terminal.";
-
 fn resolve_recipe_path(repo_root: &Path) -> Option<std::path::PathBuf> {
     if let Some(home) = dirs::home_dir() {
         let hot = home
@@ -984,24 +642,50 @@ fn resolve_recipe_path(repo_root: &Path) -> Option<std::path::PathBuf> {
     None
 }
 
-/// Concrete subprocess-based recipe runner. Shells out to
-/// `recipe-runner-rs`, delivering the episodes JSON through the shared file
-/// channel (`-c episodes_path=<abs>`) so an unbounded batch can never overflow
-/// `ARG_MAX` (issues #2640/#2692).
+/// Interpret a finished `recipe-runner-rs` invocation by its **exit status
+/// alone** (issue #2679).
+///
+/// This is the entire result-path interpretation now: a clean (exit-0) run is
+/// SUCCESS regardless of what landed on stdout — the distiller committed its
+/// facts through the memory write boundary, so an empty or banner/ANSI/trailing-
+/// comma-polluted terminal is expected, not an error. There is **no parse**, so
+/// noisy stdout can no longer fail the pipeline. A non-zero exit is the only
+/// failure the result path can report; it is surfaced with truncated
+/// stderr/stdout context (never silently swallowed).
+pub fn interpret_recipe_exit(output: &std::process::Output) -> SimardResult<()> {
+    if output.status.success() {
+        return Ok(());
+    }
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    Err(SimardError::RpcError(format!(
+        "distill: recipe exited with {}: stderr={} stdout={}",
+        output.status,
+        truncate(stderr.trim(), 200),
+        truncate(stdout.trim(), 200)
+    )))
+}
+
+/// Concrete subprocess-based recipe runner. Shells out to `recipe-runner-rs`,
+/// delivering the episodes JSON through the shared file channel
+/// (`-c episodes_path=<abs>`) so an unbounded batch can never overflow `ARG_MAX`
+/// (issues #2640/#2692), and pointing the distiller agent at the memory socket
+/// so its `simard memory remember` calls reach the daemon's write-boundary gate
+/// (issue #2679).
 pub struct RecipeRunnerSubprocess {
     recipe_path: std::path::PathBuf,
     agent_binary: &'static str,
+    /// The memory IPC socket the distiller agent's `simard memory remember`
+    /// calls must reach. Resolved once at construction from the daemon's state
+    /// root and exported to the recipe subprocess so the agent commits into the
+    /// same store this pass marks.
+    memory_socket: std::path::PathBuf,
 }
 
 impl RecipeRunnerSubprocess {
-    /// Construct a runner if all preconditions are met. Returns
-    /// `None` when:
-    ///
-    /// - The recipe file is not found in either the hot-reload or
-    ///   in-tree location.
-    /// - No agent binary is configured (no `AMPLIHACK_AGENT_BINARY`
-    ///   env var, no fallback path).
-    /// - `recipe-runner-rs` is not on `PATH`.
+    /// Construct a runner if all preconditions are met. Returns `None` when the
+    /// recipe file is not found, no agent binary is configured, or
+    /// `recipe-runner-rs` is not on `PATH`.
     pub fn new(repo_root: &Path) -> Option<Self> {
         let recipe_path = resolve_recipe_path(repo_root)?;
         let agent_binary = crate::session_builder::LlmProvider::resolve_agent_binary()?;
@@ -1015,104 +699,33 @@ impl RecipeRunnerSubprocess {
         {
             return None;
         }
+        // Resolve the memory socket the distiller must write through. This is the
+        // same path the daemon publishes (`socket_path_for(state_root)`); we hand
+        // it to the agent so its `simard memory remember` calls reach the live
+        // gate rather than falling back to an un-gated direct open.
+        let memory_socket =
+            crate::memory_ipc::socket_path_for(&crate::state_root::simard_state_root());
         Some(Self {
             recipe_path,
             agent_binary,
+            memory_socket,
         })
     }
-}
-
-impl DistillRecipeRunner for RecipeRunnerSubprocess {
-    fn run(&self, episodes: &[CognitiveEpisode]) -> SimardResult<Vec<DistilledFact>> {
-        let document = self.invoke_recipe(episodes, false)?;
-        let parsed = parse_facts(&document);
-        crate::recipe_output::record_parse_outcome("distill", parsed.is_ok());
-        parsed
-    }
-
-    fn run_all(&self, episodes: &[CognitiveEpisode]) -> SimardResult<DistillOutput> {
-        let document = self.invoke_recipe(episodes, false)?;
-        let parsed = parse_facts_document(&document);
-        crate::recipe_output::record_parse_outcome("distill", parsed.is_ok());
-        parsed
-    }
-
-    fn run_all_reinforced(
-        &self,
-        episodes: &[CognitiveEpisode],
-        strict_json: bool,
-    ) -> SimardResult<DistillOutput> {
-        // Issue #2468: on a retry (`strict_json = true`) thread a non-empty
-        // `strict_json_instruction` context var into the recipe so the agent
-        // writes ONLY the `{ "facts": [...] }` object to the facts file.
-        //
-        // Delegates to the capturing variant so the parse + metric logic lives in
-        // exactly one place; the harvested document is simply dropped here.
-        self.run_all_reinforced_capturing(episodes, strict_json)
-            .result
-    }
-
-    fn run_all_reinforced_capturing(
-        &self,
-        episodes: &[CognitiveEpisode],
-        strict_json: bool,
-    ) -> DistillAttemptOutcome {
-        // A spawn/terminal/missing-file failure produced no facts document, so
-        // there is nothing to harvest — surface the error with no raw.
-        let document = match self.invoke_recipe(episodes, strict_json) {
-            Ok(document) => document,
-            Err(e) => {
-                return DistillAttemptOutcome {
-                    result: Err(e),
-                    raw_on_failure: None,
-                };
-            }
-        };
-        let parsed = parse_facts_document(&document);
-        crate::recipe_output::record_parse_outcome("distill", parsed.is_ok());
-        // On a parse failure keep the exact facts-file bytes the parser saw so
-        // Wave 1 raw-capture can persist a real currently-failing sample.
-        let raw_on_failure = if parsed.is_err() {
-            Some(document)
-        } else {
-            None
-        };
-        DistillAttemptOutcome {
-            result: parsed,
-            raw_on_failure,
-        }
-    }
-}
 
-impl RecipeRunnerSubprocess {
-    /// Shell out to `recipe-runner-rs` with the episodes payload and return
-    /// the recipe's raw stdout. Shared by [`run`](DistillRecipeRunner::run)
-    /// and [`run_all`](DistillRecipeRunner::run_all).
+    /// Shell out to `recipe-runner-rs` with the episodes payload and return the
+    /// finished process `Output`. The distiller agent commits its facts DIRECTLY
+    /// through the memory tool during the run (issue #2679), so this returns the
+    /// raw `Output` and NEVER reads stdout for facts — [`interpret_recipe_exit`]
+    /// decides success purely from the exit status.
     ///
-    /// `strict_json` (issue #2468) threads a `strict_json_instruction` context
-    /// var into the recipe: empty on the first attempt, and a "write ONLY the
-    /// `{ \"facts\": [...] }` object to the facts file" reinforcement sentence on
-    /// a retry after a transient parse miss. The recipe interpolates it via the
-    /// pure `{{strict_json_instruction}}` substitution, so no conditional
-    /// templating engine is needed.
-    ///
-    /// Returns the **contents of the dedicated facts file** the distill agent was
-    /// instructed to write — NOT the recipe's stdout. This is the issues
-    /// #2622/#2619 fix: the copilot launcher banner (`… launching copilot
-    /// binary=… version="GitHub Copilot CLI …"`) and other log noise land on
-    /// stdout and were previously captured AS the distill step's `output`, so a
-    /// stdout scan for `{ "facts": [...] }` matched the banner and every pass
-    /// failed with `parse-failure`. Routing the agent's answer through a private
-    /// file (`-c facts_output_path=…`) makes that contamination structurally
-    /// impossible: stdout is never read for the result.
+    /// `pass_id` tags every `simard memory remember` write from this run so the
+    /// daemon's per-pass ledger can report back how many facts the gate accepted
+    /// (the only way to count facts on a path with no returned document).
     fn invoke_recipe(
         &self,
         episodes: &[CognitiveEpisode],
-        strict_json: bool,
-    ) -> SimardResult<String> {
-        // Serialize episodes as a compact JSON array. Each entry
-        // exposes the four fields the recipe prompt references:
-        // `id`, `source_label`, `temporal_index`, `content`.
+        pass_id: &str,
+    ) -> SimardResult<std::process::Output> {
         let payload: Vec<serde_json::Value> = episodes
             .iter()
             .map(|e| {
@@ -1130,43 +743,9 @@ impl RecipeRunnerSubprocess {
             ))
         })?;
 
-        // Dedicated, per-invocation facts file the distill agent writes its JSON
-        // envelope to (issues #2622/#2619). A fresh tempdir (mode 0700 via the
-        // `tempfile` crate) gives a unique absolute path with no cross-invocation
-        // races; the directory and its contents are removed when `facts_dir`
-        // drops at the end of this call, AFTER we have read the file. The agent
-        // is told this absolute path via `-c facts_output_path=…` and the recipe
-        // prompt instructs it to write ONLY the envelope there.
-        let facts_dir = tempfile::Builder::new()
-            .prefix("simard-distill-")
-            .tempdir()
-            .map_err(|e| {
-                SimardError::RpcError(format!(
-                    "distill: failed to create facts output tempdir: {e}"
-                ))
-            })?;
-        let facts_path = facts_dir.path().join("facts.json");
-        let facts_path_arg = facts_path.to_string_lossy().into_owned();
-
-        // `strict_json_instruction` (issue #2468) is always passed so the
-        // recipe's `{{strict_json_instruction}}` substitution resolves: empty on
-        // the first attempt, and a format-reinforcement sentence on a retry. The
-        // agent binary is still selected via the proven `AMPLIHACK_AGENT_BINARY`
-        // env var. `--output-format json` is retained only so a runner-level
-        // failure surfaces a structured error on stdout for the message below;
-        // the distill result itself is read from `facts_path`, never stdout.
-        let strict_json_instruction = if strict_json {
-            STRICT_JSON_INSTRUCTION
-        } else {
-            ""
-        };
         // Route the (unbounded) episodes batch through the shared file channel:
         // up to 50 full-text episodes is far more than a single argv token can
-        // hold, so inlining `-c episodes=<json>` risked the same E2BIG spawn
-        // failure the journal hit (issues #2640/#2692). The payload goes to a
-        // private temp file and only `episodes_path=<abs>` rides on argv; the
-        // guard lives until after `output()` so the file exists while the recipe
-        // reads it.
+        // hold (issues #2640/#2692). The guard lives until after `output()`.
         let episodes_cf =
             crate::recipe_context_file::ContextFile::write("distill", "episodes", &payload_json)
                 .map_err(|e| {
@@ -1174,60 +753,86 @@ impl RecipeRunnerSubprocess {
                         "distill: episodes context-file write failed: {e}"
                     ))
                 })?;
+
+        let socket_arg = self.memory_socket.to_string_lossy().into_owned();
         let output = Command::new("recipe-runner-rs")
             .arg(self.recipe_path.as_os_str())
             .env("AMPLIHACK_AGENT_BINARY", self.agent_binary)
-            .arg("--output-format")
-            .arg("json")
+            // Export the socket so the agent's `simard memory remember` resolves
+            // the SAME daemon this pass marks episodes against, with no un-gated
+            // fallback (issue #2679).
+            .env("SIMARD_MEMORY_SOCKET", &self.memory_socket)
+            // Tag this pass so the daemon's write ledger can report accepted-fact
+            // counts back to this runner. The agent invokes `simard memory
+            // remember` with only the content flags (no `--pass-id`), so the CLI
+            // reads this env var as its pass-id source (issue #2679). This env
+            // var is the ONLY channel — it is inherited by every remember
+            // subprocess the agent spawns.
+            .env(crate::memory_ipc::DISTILL_PASS_ID_ENV, pass_id)
             .arg("-c")
             .arg(episodes_cf.arg_value())
             .arg("-c")
-            .arg(format!("strict_json_instruction={strict_json_instruction}"))
-            .arg("-c")
-            .arg(format!("facts_output_path={facts_path_arg}"))
+            .arg(format!("memory_socket={socket_arg}"))
             .output()
             .map_err(|e| {
                 SimardError::RpcError(format!("distill: recipe-runner-rs spawn failed: {e}"))
             })?;
+        Ok(output)
+    }
 
-        harvest_facts_file(&output, &facts_path)
+    /// Best-effort: ask the daemon how many facts the write-boundary gate
+    /// accepted for `pass_id`, draining the ledger entry. Any transport failure
+    /// (no daemon, socket gone) yields `0` — telemetry must never fail a pass.
+    fn drain_pass_ledger(&self, pass_id: &str) -> u32 {
+        match crate::memory_ipc::RemoteCognitiveMemory::connect(&self.memory_socket) {
+            Ok(client) => client.drain_pass_ledger(pass_id).unwrap_or(0) as u32,
+            Err(_) => 0,
+        }
     }
 }
 
-/// Post-process a finished `recipe-runner-rs` invocation into the distill
-/// agent's facts document, reading it from the dedicated facts file — NEVER from
-/// stdout (issues #2622/#2619).
-///
-/// * A non-zero exit is surfaced as an explicit terminal error carrying both the
-///   truncated stderr and stdout, so a failed run is never silent.
-/// * On a clean (exit-0) run the agent's answer is read from `facts_path`. A
-///   missing file means the agent produced no output this attempt — an explicit,
-///   retry-eligible error. There is deliberately NO stdout fallback: scraping
-///   stdout is exactly the launcher-banner contamination this fix removes.
-///
-/// Split out of [`RecipeRunnerSubprocess::invoke_recipe`] so the "stdout noise is
-/// ignored" contract is hermetically testable without spawning a subprocess.
-fn harvest_facts_file(output: &std::process::Output, facts_path: &Path) -> SimardResult<String> {
-    if !output.status.success() {
-        // On failure the runner exits non-zero AND emits the structured error
-        // inside the JSON envelope on stdout (stderr may be empty), so surface
-        // both — never a silent or context-free failure.
-        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
-        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
-        return Err(SimardError::RpcError(format!(
-            "distill: recipe exited with {}: stderr={} stdout={}",
-            output.status,
-            truncate(stderr.trim(), 200),
-            truncate(stdout.trim(), 200)
-        )));
+/// Generate a process-unique distill pass id for the write ledger.
+fn new_pass_id() -> String {
+    use std::time::{SystemTime, UNIX_EPOCH};
+    let nanos = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_nanos())
+        .unwrap_or(0);
+    format!("distill-pass-{nanos}-{}", std::process::id())
+}
+
+impl DistillRecipeRunner for RecipeRunnerSubprocess {
+    fn run(&self, episodes: &[CognitiveEpisode]) -> SimardResult<Vec<DistilledFact>> {
+        // The distiller commits its facts DIRECTLY through the memory tool during
+        // the run, so there is no returned document. We only interpret the exit
+        // status; on success there are no facts for Simard to hand back.
+        let output = self.invoke_recipe(episodes, &new_pass_id())?;
+        interpret_recipe_exit(&output)?;
+        Ok(Vec::new())
     }
 
-    std::fs::read_to_string(facts_path).map_err(|e| {
-        SimardError::RpcError(format!(
-            "distill: facts output file was not written by the agent ({}): {e}",
-            facts_path.display()
-        ))
-    })
+    fn run_agentic(
+        &self,
+        episodes: &[CognitiveEpisode],
+        _sink: &mut dyn DistillFactSink,
+    ) -> SimardResult<DistillCommit> {
+        // The agent's `simard memory remember` writes ARE the output — the
+        // in-process sink is unused on this path. Interpret the recipe by its
+        // exit status alone (issue #2679): noisy/trailing-comma/banner stdout can
+        // no longer fail the pipeline because nothing is parsed.
+        let pass_id = new_pass_id();
+        let output = self.invoke_recipe(episodes, &pass_id)?;
+        interpret_recipe_exit(&output)?;
+        // Report the gate-accepted fact count for this pass (best-effort). We do
+        // not distinguish stored vs. quarantined on the real path (the agent's
+        // per-fact CLI already surfaces each disposition); the ledger counts only
+        // accepted facts.
+        Ok(DistillCommit {
+            facts: self.drain_pass_ledger(&pass_id),
+            quarantined: 0,
+            procedures: 0,
+        })
+    }
 }
 
 fn truncate(s: &str, max: usize) -> String {
@@ -1239,332 +844,18 @@ fn truncate(s: &str, max: usize) -> String {
     }
 }
 
-/// Parse the distill agent's facts document into a list of [`DistilledFact`].
-///
-/// Thin facts-only wrapper over [`parse_facts_document`] retained for the legacy
-/// [`DistillRecipeRunner::run`] entry point and its unit tests.
-pub(crate) fn parse_facts(document: &str) -> SimardResult<Vec<DistilledFact>> {
-    parse_facts_document(document).map(|o| o.facts)
-}
-
-/// Parse the distill agent's **facts document** into a [`DistillOutput`] (facts
-/// AND procedures).
-///
-/// `document` is the contents of the dedicated facts file the distill agent was
-/// instructed to write (`-c facts_output_path=…`), NOT recipe-runner stdout.
-/// Because the agent writes ONLY its JSON envelope to that private file, the
-/// copilot launcher banner and log lines that contaminate stdout can never reach
-/// here — this is the structural fix for the issues #2622/#2619 `parse-failure`
-/// mode where the launcher banner was captured as the distill step output and a
-/// stdout scan for `{ "facts": [...] }` matched the banner instead of the answer.
-///
-/// Parsing is deliberately simple, reflecting the clean channel:
-///
-/// 1. An empty document means the agent produced no output — an explicit,
-///    retry-eligible `Err` (never a hollow `Ok`; no silent stdout fallback).
-/// 2. Otherwise [`scan_cleaned_for_facts`] deserializes the
-///    `{ "facts": [...], "procedures": [...] }` envelope, tolerating a Markdown
-///    code fence or a little leading/trailing prose the agent may wrap around its
-///    own answer in the file (field/format leniency on a clean channel — NOT the
-///    launcher-banner stdout scraping this fix removed).
-/// 3. If no facts object is present, return `Err`; the caller treats `Err` as
-///    the retry-safe "no markers set" path.
-pub(crate) fn parse_facts_document(document: &str) -> SimardResult<DistillOutput> {
-    let trimmed = document.trim();
-    if trimmed.is_empty() {
-        return Err(SimardError::RpcError(
-            "distill: facts document was empty; the agent produced no output".to_string(),
-        ));
-    }
-    if let Some(output) = scan_cleaned_for_facts(trimmed) {
-        return Ok(output);
-    }
-    Err(SimardError::RpcError(format!(
-        "distill: facts document did not contain a parseable {{ \"facts\": [...] }} object: {}",
-        truncate(trimmed, 200)
-    )))
-}
-
-/// Parse a bare `{ "facts": [...] }` object, tolerating a single **trailing
-/// comma** malformation as a last resort (issue #2658).
-///
-/// Strict `serde_json` is attempted first, so the clean path is byte-identical
-/// and unchanged. Only when that fails is a retry attempted on the
-/// [`strip_json_trailing_commas`](crate::recipe_output::strip_json_trailing_commas)
-/// view — a provable no-op on valid JSON — so one cosmetic trailing comma
-/// before a `}`/`]` (the single most common LLM-JSON defect) can no longer
-/// reject the whole facts object and silently drop the entire batch (the
-/// residual 100% distill parse-failure shape). A genuinely malformed object
-/// (not just a trailing comma) leaves the stripped view unchanged, so it still
-/// fails and precision is never weakened.
-fn parse_facts_envelope_lenient(text: &str) -> Option<RecipeEnvelope> {
-    if let Ok(parsed) = serde_json::from_str::<RecipeEnvelope>(text) {
-        return Some(parsed);
-    }
-    // The stripper borrows the input unchanged when it holds no trailing comma,
-    // so a `Borrowed` result means the strict parse above already saw these
-    // exact bytes and failed — there is nothing new to try. Only an `Owned`
-    // (actually-stripped) view can parse where the strict attempt could not.
-    match crate::recipe_output::strip_json_trailing_commas(text) {
-        std::borrow::Cow::Owned(stripped) => serde_json::from_str::<RecipeEnvelope>(&stripped).ok(),
-        std::borrow::Cow::Borrowed(_) => None,
-    }
-}
-
-/// Scan an already noise-stripped `trimmed` string for a `{ "facts": [...] }`
-/// object, preferring (in order) the LAST balanced object candidate that carries
-/// a **grounded-capable** fact — one with a non-empty `source_episode_id` — then
-/// the last otherwise-non-empty object, then the last parseable empty object.
-/// Candidates are the balanced `{...}` substrings returned by
-/// [`crate::recipe_output::balanced_objects`] (string-aware, and resilient to an
-/// unmatched `{` in leading prose). The empty-document guard and the caller
-/// contract live in [`parse_facts_document`].
-///
-/// The grounded-capable tier exists because field-level leniency
-/// ([`de_lenient_string`]) lets a *source-less* facts object now parse as
-/// "non-empty"; without this tier a trailing source-less object (which the
-/// reliability gate would later quarantine wholesale) could shadow an earlier
-/// fully-attributed answer and silently discard its promotable facts. Preferring
-/// the grounded-capable object keeps the agent's real, attributed answer winning
-/// while still recovering a source-less answer when that is all the output holds.
-fn scan_cleaned_for_facts(trimmed: &str) -> Option<DistillOutput> {
-    // Fast path — the text IS the JSON object.
-    if let Some(parsed) = parse_facts_envelope_lenient(trimmed) {
-        return Some(parsed.into_output());
-    }
-    // Slow path — among every balanced `{...}` substring (string-aware, so a
-    // brace inside a JSON string cannot split an object), scanned from the END
-    // so the agent's final answer is reached before any leading banner/thinking
-    // object. The shared `recipe_output::balanced_objects` helper restarts at
-    // the next `{` after an unmatched/never-closing brace, so a stray `{` in the
-    // distill agent's leading prose (e.g. a code fragment like `fn f() {` while
-    // it reasons about code episodes) can no longer demote the real answer to a
-    // nested object and silently drop it (issue #2508). Three preference tiers
-    // (best first):
-    //   1. last object with a grounded-capable fact (non-empty source_episode_id),
-    //   2. last otherwise-non-empty object (facts/procedures present),
-    //   3. last parseable empty `{"facts":[]}` ("nothing worth distilling").
-    let mut nonempty_fallback: Option<DistillOutput> = None;
-    let mut empty_fallback: Option<DistillOutput> = None;
-    for span in crate::recipe_output::balanced_objects(trimmed)
-        .into_iter()
-        .rev()
-    {
-        if let Some(parsed) = parse_facts_envelope_lenient(span) {
-            let output = parsed.into_output();
-            if output
-                .facts
-                .iter()
-                .any(|f| !f.source_episode_id.trim().is_empty())
-            {
-                return Some(output);
-            }
-            if !output.facts.is_empty() || !output.procedures.is_empty() {
-                if nonempty_fallback.is_none() {
-                    nonempty_fallback = Some(output);
-                }
-            } else if empty_fallback.is_none() {
-                empty_fallback = Some(output);
-            }
-        }
-    }
-    nonempty_fallback.or(empty_fallback)
-}
-
-#[derive(serde::Deserialize)]
-struct RecipeEnvelope {
-    facts: Vec<RecipeFact>,
-    #[serde(default)]
-    procedures: Vec<RecipeProcedure>,
-}
-
-/// Deserialize a fact/procedure field that the distiller agent is *supposed* to
-/// emit as a JSON string but, in practice, intermittently omits, nulls, or
-/// emits as a bare scalar (the Copilot CLI agent does this for individual
-/// `facts[]` entries — observed live in production, e.g. episode t=9664; see
-/// issue #2506).
-///
-/// Without this, a single fact missing `source_episode_id` (or carrying a
-/// `null`/numeric value) made `serde` reject the **entire** `{ "facts": [...] }`
-/// envelope, so [`parse_facts_document`] found no parseable object and the whole
-/// batch was silently dropped with the recurring
-/// `` facts document did not contain a parseable { "facts": [...] } `` error —
-/// burning an LLM call every cycle while the same batch deferred forever.
-///
-/// Tolerating field-level noise lets the **well-formed** facts in a batch be
-/// recovered instead of one malformed sibling sinking all of them. Quality is
-/// not weakened: a recovered fact with an empty/unknown `source_episode_id` is
-/// ungrounded and the existing reliability gate ([`assess_fact_reliability`])
-/// quarantines it; an empty `concept` is dropped by [`RecipeEnvelope::into_facts`];
-/// empty `content` is quarantined by the reliability hard gate. Coercion is
-/// limited to **scalars** (string / number / bool); a `null` or a non-scalar
-/// (array / object) — both of which are malformed for a field the recipe
-/// promises as a plain string — collapses to the empty string so the existing
-/// gates drop/quarantine it rather than letting structured JSON text smuggle a
-/// fact past them.
-fn de_lenient_string<'de, D>(deserializer: D) -> Result<String, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    use serde::Deserialize;
-    Ok(match serde_json::Value::deserialize(deserializer)? {
-        serde_json::Value::String(s) => s,
-        serde_json::Value::Number(n) => n.to_string(),
-        serde_json::Value::Bool(b) => b.to_string(),
-        // Null and any non-scalar (array/object) → empty: a malformed value for
-        // a promised-string field must not become non-empty `content`/`concept`
-        // that could clear the empty-content/known-concept gates.
-        serde_json::Value::Null | serde_json::Value::Array(_) | serde_json::Value::Object(_) => {
-            String::new()
-        }
-    })
-}
-
-#[derive(serde::Deserialize)]
-struct RecipeFact {
-    #[serde(default, deserialize_with = "de_lenient_string")]
-    concept: String,
-    #[serde(default, deserialize_with = "de_lenient_string")]
-    content: String,
-    #[serde(default, deserialize_with = "de_lenient_string")]
-    source_episode_id: String,
-}
-
-#[derive(serde::Deserialize)]
-struct RecipeProcedure {
-    #[serde(default, deserialize_with = "de_lenient_string")]
-    name: String,
-    #[serde(default)]
-    steps: Vec<String>,
-    #[serde(default)]
-    source_episode_ids: Vec<String>,
-}
-
-/// Canonicalize a recipe-emitted concept label to one of the fixed
-/// [`KNOWN_DISTILL_CONCEPTS`], or `None` if it is genuinely off-spec.
-///
-/// The distillation recipe's prompt constrains the label to the closed set
-/// `{pr-pattern, bug-pattern, lesson-learned}`, but an LLM routinely varies the
-/// *surface form* of a label it clearly intends: title/upper case
-/// (`"PR-Pattern"`, `"BUG-PATTERN"`), surrounding whitespace or quotes/sentence
-/// punctuation (`" bug-pattern "`, `"pr-pattern."`), and space/underscore
-/// separators (`"pr_pattern"`, `"lesson learned"`). The legacy exact-match
-/// filter silently dropped every such fact — a well-formed, grounded fact lost
-/// purely to cosmetics, depressing distillation fact-yield.
-///
-/// Canonicalization recovers those facts (higher yield) **without weakening
-/// precision**: normalization only folds case, trims surrounding
-/// whitespace/quotes/sentence-punctuation, and unifies `_`/space→`-` (collapsing
-/// repeated hyphens) before an EXACT match against the three labels. A concept
-/// that does not normalize to one of them — `"made-up-label"`, `"skip"`,
-/// `"pr-patterns"`, `"pull-request"` — still returns `None` and is dropped. The
-/// three labels are lexically distinct, so no genuinely different concept can
-/// alias onto another. The returned value is the canonical lower-hyphen form,
-/// so the stored concept is uniform for downstream dedup/recall regardless of
-/// how the model spelled it.
-pub(crate) fn canonical_distill_concept(raw: &str) -> Option<&'static str> {
-    // Fold case, then strip surrounding whitespace and the quote/sentence
-    // punctuation a model sometimes wraps a label in.
-    let trimmed = raw
-        .trim()
-        .trim_matches(|c: char| {
-            c.is_whitespace() || matches!(c, '"' | '\'' | '`' | '.' | ',' | ':' | ';')
-        })
-        .to_ascii_lowercase();
-
-    // Unify separators (`_` and interior spaces behave as `-`) and collapse runs
-    // of hyphens, then trim any leading/trailing hyphens the folding produced.
-    let mut canon = String::with_capacity(trimmed.len());
-    let mut prev_hyphen = false;
-    for ch in trimmed.chars() {
-        let c = if ch == '_' || ch == ' ' { '-' } else { ch };
-        if c == '-' {
-            if !prev_hyphen {
-                canon.push('-');
-            }
-            prev_hyphen = true;
-        } else {
-            canon.push(c);
-            prev_hyphen = false;
-        }
-    }
-    let canon = canon.trim_matches('-');
-
-    match canon {
-        "pr-pattern" => Some("pr-pattern"),
-        "bug-pattern" => Some("bug-pattern"),
-        "lesson-learned" => Some("lesson-learned"),
-        _ => None,
-    }
-}
-
-impl RecipeEnvelope {
-    fn into_facts(self) -> Vec<DistilledFact> {
-        // Keep only facts whose concept canonicalizes to one of the three
-        // documented labels so the recipe cannot sneak new labels past the
-        // contract — but tolerate the LLM's surface-form variation (case /
-        // whitespace / `_`↔`-`) of a label it clearly intends. Off-spec
-        // concepts (incl. `skip` if it ever lands here) still return `None` and
-        // are dropped; recovered facts are stored under the canonical label.
-        self.facts
-            .into_iter()
-            .filter_map(|f| {
-                canonical_distill_concept(&f.concept).map(|concept| DistilledFact {
-                    concept: concept.to_string(),
-                    content: f.content,
-                    source_episode_id: f.source_episode_id,
-                })
-            })
-            .collect()
-    }
-
-    fn into_procedures(self) -> Vec<DistilledProcedure> {
-        // Keep only procedures that name at least one source episode so a
-        // `PROCEDURE_DERIVES_FROM` edge can actually be drawn, and that carry
-        // at least one step. Unnamed / empty procedures are dropped.
-        self.procedures
-            .into_iter()
-            .filter(|p| {
-                !p.name.trim().is_empty() && !p.steps.is_empty() && !p.source_episode_ids.is_empty()
-            })
-            .map(|p| DistilledProcedure {
-                name: p.name,
-                steps: p.steps,
-                source_episode_ids: p.source_episode_ids,
-            })
-            .collect()
-    }
-
-    fn into_output(self) -> DistillOutput {
-        let RecipeEnvelope { facts, procedures } = self;
-        DistillOutput {
-            facts: RecipeEnvelope {
-                facts,
-                procedures: Vec::new(),
-            }
-            .into_facts(),
-            procedures: RecipeEnvelope {
-                facts: Vec::new(),
-                procedures,
-            }
-            .into_procedures(),
-        }
-    }
-}
-
 #[cfg(test)]
 mod unit_tests {
     use super::*;
 
     #[test]
     fn reliability_gate_metric_context_shape() {
-        // 5 candidates, 2 quarantined → block_rate 0.4.
-        let payload = build_reliability_gate_context(5, 2, 3);
+        let payload = build_reliability_gate_context(4, 1, 3);
         let v: serde_json::Value = serde_json::from_str(&payload).unwrap();
-        assert_eq!(v["candidate_facts"], 5);
+        assert_eq!(v["candidate_facts"], 4);
         assert_eq!(v["promoted"], 3);
-        assert_eq!(v["quarantined"], 2);
-        assert_eq!(v["block_rate"], 0.4);
+        assert_eq!(v["quarantined"], 1);
+        assert_eq!(v["block_rate"], 0.25);
         assert_eq!(v["threshold"], DISTILL_RELIABILITY_THRESHOLD);
     }
 
@@ -1583,11 +874,11 @@ mod unit_tests {
     #[test]
     fn report_with_work_is_not_was_skipped() {
         let r = DistillReport {
-            input_count: 25,
-            fact_count: 3,
+            input_count: 20,
+            fact_count: 2,
             procedure_count: 0,
-            marked_count: 25,
-            quarantined_count: 0,
+            marked_count: 20,
+            quarantined_count: 1,
         };
         assert!(!r.was_skipped());
     }
@@ -1606,772 +897,66 @@ mod unit_tests {
             marked_count: 25,
             quarantined_count: 0,
         };
-        let pct = r.reduction() * 100.0;
-        assert!((pct - 88.0).abs() < 0.1, "expected ~88%, got {pct}");
-    }
-
-    #[test]
-    fn parse_recipe_output_accepts_plain_object() {
-        let raw =
-            r#"{"facts":[{"concept":"pr-pattern","content":"x","source_episode_id":"epi_1"}]}"#;
-        let facts = parse_facts(raw).unwrap();
-        assert_eq!(facts.len(), 1);
-        assert_eq!(facts[0].concept, "pr-pattern");
-    }
-
-    #[test]
-    fn parse_recipe_output_extracts_json_from_prose() {
-        let raw = r#"Sure, here is the JSON:
-            {"facts":[{"concept":"bug-pattern","content":"y","source_episode_id":"epi_2"}]}
-            That's all."#;
-        let facts = parse_facts(raw).unwrap();
-        assert_eq!(facts.len(), 1);
-        assert_eq!(facts[0].concept, "bug-pattern");
-    }
-
-    #[test]
-    fn parse_recipe_output_drops_unknown_concepts() {
-        let raw = r#"{"facts":[
-            {"concept":"made-up-label","content":"a","source_episode_id":"epi_1"},
-            {"concept":"lesson-learned","content":"b","source_episode_id":"epi_2"}
-        ]}"#;
-        let facts = parse_facts(raw).unwrap();
-        assert_eq!(facts.len(), 1, "made-up-label must be filtered out");
-        assert_eq!(facts[0].concept, "lesson-learned");
-    }
-
-    #[test]
-    fn canonical_concept_accepts_surface_form_variants() {
-        // Case, surrounding whitespace/quotes/punctuation, and `_`/space
-        // separators of a clearly-intended label all normalize to the canonical
-        // lower-hyphen form (higher fact-yield without lowering precision).
-        for (raw, want) in [
-            ("pr-pattern", "pr-pattern"),
-            ("PR-Pattern", "pr-pattern"),
-            ("BUG-PATTERN", "bug-pattern"),
-            (" bug-pattern ", "bug-pattern"),
-            ("Lesson-Learned", "lesson-learned"),
-            ("pr_pattern", "pr-pattern"),
-            ("lesson learned", "lesson-learned"),
-            ("pr--pattern", "pr-pattern"),
-            ("\"pr-pattern\"", "pr-pattern"),
-            ("bug-pattern.", "bug-pattern"),
-        ] {
-            assert_eq!(
-                canonical_distill_concept(raw),
-                Some(want),
-                "surface variant {raw:?} should canonicalize to {want:?}"
-            );
-        }
-    }
-
-    #[test]
-    fn canonical_concept_rejects_offspec_labels() {
-        // Precision guard: anything that does not normalize to exactly one of the
-        // three labels is still dropped — the canonicalizer must not admit
-        // near-misses, plurals, or unrelated labels.
-        for raw in [
-            "made-up-label",
-            "skip",
-            "observation",
-            "pr-patterns",
-            "pull-request",
-            "bug",
-            "pattern",
-            "",
-            "   ",
-            "pr-pattern-v2",
-            "prpattern",
-        ] {
-            assert_eq!(
-                canonical_distill_concept(raw),
-                None,
-                "off-spec label {raw:?} must be dropped"
-            );
-        }
-    }
-
-    #[test]
-    fn into_facts_recovers_surface_variant_but_drops_offspec() {
-        // End-to-end through the production parser: a case/whitespace/underscore
-        // variant is recovered (and stored canonical); an off-spec label is
-        // dropped.
-        let raw = r#"{"facts":[
-            {"concept":"PR-Pattern","content":"squash fixups","source_episode_id":"epi_1"},
-            {"concept":" bug_pattern ","content":"off by one","source_episode_id":"epi_2"},
-            {"concept":"made-up-label","content":"nope","source_episode_id":"epi_3"}
-        ]}"#;
-        let facts = parse_facts(raw).unwrap();
-        assert_eq!(
-            facts.len(),
-            2,
-            "two surface variants recovered, off-spec dropped"
-        );
-        assert_eq!(facts[0].concept, "pr-pattern");
-        assert_eq!(facts[1].concept, "bug-pattern");
-    }
-
-    #[test]
-    fn parse_recipe_output_errors_when_no_object() {
-        let raw = "no json here at all";
-        assert!(parse_facts(raw).is_err());
-    }
-
-    // ── issue #2658: trailing-comma tolerance (residual 100% parse-failure) ──
-    //
-    // A single trailing comma before a `}`/`]` is the most common real-world
-    // LLM JSON defect. Before this fix strict `serde_json` rejected the WHOLE
-    // facts object, the batch was deferred every cycle, and
-    // `distill_parse_success_rate` collapsed toward 0 (the overseer's "100%
-    // parse-failure"). These pin that one cosmetic comma no longer drops the
-    // batch, while never corrupting string content or repairing genuinely
-    // malformed JSON.
-
-    #[test]
-    fn parse_recovers_bare_trailing_comma_facts_object() {
-        // Trailing comma after the last fact object AND after the `facts` array.
-        let raw = r#"{"facts":[{"concept":"pr-pattern","content":"warm the cache before pin bumps","source_episode_id":"epi_1"},],}"#;
-        assert!(
-            serde_json::from_str::<serde_json::Value>(raw).is_err(),
-            "precondition: the trailing-comma object must be strict-invalid JSON"
-        );
-        let facts =
-            parse_facts(raw).expect("a trailing-comma facts object must recover >= 1 fact (#2658)");
-        assert_eq!(facts.len(), 1, "the single well-formed fact is salvaged");
-        assert_eq!(facts[0].concept, "pr-pattern");
-        assert_eq!(facts[0].source_episode_id, "epi_1");
-    }
-
-    #[test]
-    fn parse_recovers_trailing_comma_with_procedures() {
-        // The pretty-printed shape an agent emits into its facts file, with
-        // trailing commas after the fact, the facts array, a procedure step,
-        // and the top-level object.
-        let raw = "{\n  \"facts\": [\n    {\"concept\": \"lesson-learned\", \"content\": \"one bad token must not drop the batch\", \"source_episode_id\": \"epi_7\"},\n  ],\n  \"procedures\": [\n    {\"name\": \"ci-fix\", \"steps\": [\"re-run\",], \"source_episode_ids\": [\"epi_7\"]},\n  ],\n}";
-        let out = parse_facts_document(raw)
-            .expect("a trailing-comma facts+procedures document must recover (#2658)");
-        assert_eq!(out.facts.len(), 1);
-        assert_eq!(out.facts[0].source_episode_id, "epi_7");
-        assert_eq!(out.procedures.len(), 1);
-        assert_eq!(out.procedures[0].steps, vec!["re-run".to_string()]);
-    }
-
-    #[test]
-    fn parse_recovers_trailing_comma_object_wrapped_in_prose() {
-        // The slow (balanced-brace) path must also tolerate a trailing comma —
-        // a little leading/trailing prose around the malformed object.
-        let raw = r#"Sure, here it is:
-            {"facts":[{"concept":"bug-pattern","content":"z","source_episode_id":"epi_3"},]}
-            done."#;
-        let facts = parse_facts(raw)
-            .expect("a prose-wrapped trailing-comma object must recover via the slow path (#2658)");
-        assert_eq!(facts.len(), 1);
-        assert_eq!(facts[0].concept, "bug-pattern");
-    }
-
-    #[test]
-    fn parse_trailing_comma_recovery_never_corrupts_string_content() {
-        // `content` ends with "…, " and the object still has a real structural
-        // trailing comma before `]` — only the structural comma may be removed.
-        let raw = r#"{"facts":[{"concept":"pr-pattern","content":"rebase, squash, then merge,","source_episode_id":"epi_4"},]}"#;
-        let facts = parse_facts(raw)
-            .expect("structural trailing comma removed, string content preserved (#2658)");
-        assert_eq!(facts.len(), 1);
-        assert_eq!(
-            facts[0].content, "rebase, squash, then merge,",
-            "the comma-laden content (incl. its trailing comma) must survive verbatim"
-        );
-    }
-
-    #[test]
-    fn parse_still_fails_on_genuinely_malformed_non_trailing_comma() {
-        // An ELIDED array element `,,` is not a lone trailing comma: leniency
-        // must never widen to accept broken JSON, so precision is unchanged.
-        let raw = r#"{"facts":[{"concept":"pr-pattern","content":"a","source_episode_id":"e1"},,{"concept":"bug-pattern","content":"b","source_episode_id":"e2"}]}"#;
-        assert!(
-            parse_facts(raw).is_err(),
-            "an elided array element is not a trailing comma and must still fail (#2658)"
-        );
+        assert!((r.reduction() - 0.88).abs() < 1e-9);
     }
 
     #[test]
-    fn parse_wellformed_object_unaffected_by_trailing_comma_recovery() {
-        // Clean-path invariant: a well-formed object is parsed by the strict
-        // path; the trailing-comma retry is never reached.
-        let raw = r#"{"facts":[{"concept":"lesson-learned","content":"clean","source_episode_id":"epi_9"}]}"#;
-        let facts = parse_facts(raw).expect("well-formed object parses");
-        assert_eq!(facts.len(), 1);
-        assert_eq!(facts[0].source_episode_id, "epi_9");
-    }
-
-    // ── issue #2461: last-object-wins + string-aware extraction ──────────
-
-    #[test]
-    fn parse_recipe_output_prefers_last_facts_object_over_leading_banner() {
-        // The t=7517 / #2461 failure mode: a leading non-facts JSON banner
-        // precedes the real facts object. A first-object scan locked onto the
-        // banner and the pass silently no-opped; "last object wins" recovers it.
-        let raw = r#"{"recipe_name":"distill","status":"starting","note":"banner"}
-            {"facts":[{"concept":"lesson-learned","content":"prefer last object","source_episode_id":"epi_3"}]}"#;
-        let facts = parse_facts(raw).unwrap();
-        assert_eq!(facts.len(), 1);
-        assert_eq!(facts[0].concept, "lesson-learned");
-        assert_eq!(facts[0].content, "prefer last object");
-    }
-
-    #[test]
-    fn parse_recipe_output_tolerates_braces_inside_fact_content() {
-        // A fact whose content contains literal braces must not corrupt the
-        // string-aware brace scanner.
-        let raw = r#"thinking... {"facts":[{"concept":"bug-pattern","content":"handler for {req} leaks }","source_episode_id":"epi_4"}]}"#;
-        let facts = parse_facts(raw).unwrap();
-        assert_eq!(facts.len(), 1);
-        assert_eq!(facts[0].content, "handler for {req} leaks }");
-    }
-
-    #[test]
-    fn parse_recipe_output_handles_unmatched_quote_in_leading_prose() {
-        // A stray double-quote in prose BEFORE the JSON must not put the
-        // scanner into string mode and swallow the object's `{` opener.
-        let raw = "He said \"the answer is below:\n{\"facts\":[{\"concept\":\"pr-pattern\",\"content\":\"x\",\"source_episode_id\":\"epi_9\"}]}";
-        let facts = parse_facts(raw).unwrap();
-        assert_eq!(facts.len(), 1);
-        assert_eq!(facts[0].concept, "pr-pattern");
-    }
-
-    // ── issue #2508: unmatched `{` in leading prose must not swallow the answer ──
-    // The balanced-object scan reuses the shared `recipe_output::balanced_objects`
-    // helper (string-aware, restarts past an unmatched/never-closing `{`); that
-    // helper's own span-level unit tests live in `recipe_output::extract`,
-    // including `balanced_objects_skips_unmatched_leading_brace`. The end-to-end
-    // distillation recovery and the non-fatal fallback are pinned here.
-
-    #[test]
-    fn parse_recipe_output_recovers_from_unbalanced_brace_in_leading_prose() {
-        // The distill agent reasons about CODE episodes, so its preamble can
-        // carry a code fragment with an unmatched `{` (e.g. `fn handler() {`)
-        // before it emits the JSON answer. The old single-`depth` scan anchored
-        // on that stray brace and silently dropped the real facts object,
-        // no-opping distillation. The scanner must recover the trailing answer.
-        let raw = concat!(
-            "Looking at the episodes, the leak is in `fn handler() {` where the guard is missing.\n",
-            "Here is the distilled output:\n",
-            r#"{"facts":[{"concept":"bug-pattern","content":"missing guard in handler","#,
-            r#""source_episode_id":"epi_9900"}]}"#,
-        );
-        let facts = parse_facts(raw).expect("answer after an unmatched `{` must parse");
-        assert_eq!(facts.len(), 1);
-        assert_eq!(facts[0].concept, "bug-pattern");
-        assert_eq!(facts[0].content, "missing guard in handler");
-        assert_eq!(facts[0].source_episode_id, "epi_9900");
-    }
-
-    #[test]
-    fn parse_recipe_output_banner_only_fails_non_fatally_without_panic() {
-        // Genuinely answer-less output — only the Copilot CLI launch banner,
-        // no `{ "facts": [...] }` object anywhere — must return Err (the
-        // retry-safe "no markers set" path) without panicking. This is the
-        // t=9900 shape when the agent emits its launch preamble and no answer.
-        let raw = concat!(
-            "2026-06-30T09:00:00.000000Z  INFO launching copilot binary=copilot ",
-            "version=\"GitHub Copilot CLI 1.0.66-2\"\n",
-            "\u{2139} NODE_OPTIONS=--max-old-space-size=8192 (saved preference)\n",
-            "Run 'copilot update' to update\n",
-        );
-        assert!(parse_facts(raw).is_err());
-        // And the empty / whitespace-only shapes likewise fail without panic.
-        assert!(parse_facts("").is_err());
-        assert!(parse_facts("   \n \t ").is_err());
-    }
-
-    // ── issue #2461: failure classification ─────────────────────────────
-
-    #[test]
-    fn classify_distill_error_buckets_each_failure_mode() {
-        use DistillFailureClass::*;
-        let cases = [
-            (
-                "distill: recipe-runner-rs spawn failed: no such file",
-                SpawnFailure,
-            ),
-            (
-                "distill: failed to create facts output tempdir: permission denied",
-                SpawnFailure,
-            ),
-            (
-                "distill: recipe exited with exit status: 1: stderr= stdout=",
-                CopilotTerminalFailure,
-            ),
-            // Post-#2622/#2619 parse failures: the process exited 0 but the
-            // agent's facts document was missing, empty, or unparseable.
-            (
-                "distill: facts output file was not written by the agent (/tmp/x/facts.json): No such file or directory (os error 2)",
-                ParseFailure,
-            ),
-            (
-                "distill: facts document was empty; the agent produced no output",
-                ParseFailure,
-            ),
-            (
-                "distill: facts document did not contain a parseable { \"facts\": [...] } object: hi",
-                ParseFailure,
-            ),
-            (
-                "distill: failed to serialize episodes payload: oops",
-                SerializeFailure,
-            ),
-            ("something unexpected", Other),
-        ];
-        for (msg, expected) in cases {
-            let err = SimardError::RpcError(msg.to_string());
-            assert_eq!(classify_distill_error(&err), expected, "msg: {msg}");
-        }
-    }
-
-    #[test]
-    fn classify_anchors_on_prefix_not_embedded_stdout() {
-        // A terminal failure embeds the recipe's stdout, which may itself
-        // contain the parse-failure phrase; prefix anchoring must keep it a
-        // terminal failure so recipe_exited_ok stays false.
+    fn classify_terminal_failure_anchors_on_prefix_not_embedded_stdout() {
+        // A non-zero exit whose embedded stdout mentions unrelated text must
+        // still classify as a terminal failure, not `Other`.
         let terminal = SimardError::RpcError(
-            "distill: recipe exited with exit status: 1: stderr= stdout=recipe run did not \
-             yield a parseable object"
-                .to_string(),
+            "distill: recipe exited with exit status: 1: stderr= stdout={\"facts\":[]}".to_string(),
         );
         assert_eq!(
             classify_distill_error(&terminal),
             DistillFailureClass::CopilotTerminalFailure
         );
-        assert!(!classify_distill_error(&terminal).recipe_exited_ok());
-    }
-
-    #[test]
-    fn classify_non_bridge_error_is_other() {
-        let err = SimardError::PlanningUnavailable {
-            reason: "backend down".to_string(),
-        };
-        assert_eq!(classify_distill_error(&err), DistillFailureClass::Other);
-    }
-
-    // ── issue #2468: retry-aware metric context ─────────────────────────────
-
-    /// PR-1 (#2468): the `distill_success_rate` context distinguishes
-    /// first-attempt success from post-retry recovery so
-    /// `distill_parse_success_rate` can tell them apart. The extended
-    /// `build_distill_success_context` therefore carries `attempt` (1-based) and
-    /// `recovered_after_retry`.
-    #[test]
-    fn distill_success_context_carries_attempt_and_recovery() {
-        // First-attempt success.
-        let first = build_distill_success_context(true, None, 20, 3, 1, false);
-        let v: serde_json::Value = serde_json::from_str(&first).unwrap();
-        assert_eq!(v["attempt"], 1);
-        assert_eq!(v["recovered_after_retry"], false);
-        assert_eq!(v["parse_success"], true);
-
-        // Recovered on the second attempt after a transient miss.
-        let recovered = build_distill_success_context(true, None, 20, 3, 2, true);
-        let v2: serde_json::Value = serde_json::from_str(&recovered).unwrap();
-        assert_eq!(v2["attempt"], 2);
-        assert_eq!(v2["recovered_after_retry"], true);
-        assert_eq!(v2["parse_success"], true);
-    }
-
-    #[test]
-    fn parse_failure_is_the_only_class_that_reached_parsing() {
-        use DistillFailureClass::*;
-        // recipe_exited_ok: process exited 0 → only parse-failure.
-        assert!(ParseFailure.recipe_exited_ok());
-        assert!(!CopilotTerminalFailure.recipe_exited_ok());
-        assert!(!SpawnFailure.recipe_exited_ok());
-        assert!(!SerializeFailure.recipe_exited_ok());
-        // reached_parsing: only parse-failure actually reached the agent output.
-        assert!(ParseFailure.reached_parsing());
-        assert!(!CopilotTerminalFailure.reached_parsing());
-    }
-
-    // ── issue #2461: distill_success_rate metric context ────────────────
-
-    #[test]
-    fn success_metric_context_marks_parse_attempted_and_parse_success() {
-        let payload = build_distill_success_context(true, None, 25, 3, 1, false);
-        let v: serde_json::Value = serde_json::from_str(&payload).unwrap();
-        assert_eq!(v["outcome"], "success");
-        assert_eq!(v["recipe_exited_ok"], true);
-        assert_eq!(v["parse_attempted"], true);
-        assert_eq!(v["parse_success"], true);
-        assert!(v["failure_class"].is_null());
-        assert_eq!(v["input_count"], 25);
-        assert_eq!(v["fact_count"], 3);
-    }
-
-    #[test]
-    fn parse_failure_metric_context_attempted_parsing_but_failed() {
-        let payload = build_distill_success_context(
-            false,
-            Some(DistillFailureClass::ParseFailure),
-            40,
-            0,
-            1,
-            false,
-        );
-        let v: serde_json::Value = serde_json::from_str(&payload).unwrap();
-        assert_eq!(v["outcome"], "failure");
-        assert_eq!(v["recipe_exited_ok"], true, "parse failure means exit 0");
-        assert_eq!(v["parse_attempted"], true);
-        assert_eq!(v["parse_success"], false);
-        assert_eq!(v["failure_class"], "parse-failure");
-    }
-
-    #[test]
-    fn terminal_failure_metric_context_did_not_reach_parsing() {
-        let payload = build_distill_success_context(
-            false,
-            Some(DistillFailureClass::CopilotTerminalFailure),
-            40,
-            0,
-            1,
-            false,
-        );
-        let v: serde_json::Value = serde_json::from_str(&payload).unwrap();
-        assert_eq!(v["recipe_exited_ok"], false);
-        assert_eq!(v["parse_attempted"], false);
-        assert_eq!(v["parse_success"], false);
-        assert_eq!(v["failure_class"], "copilot-terminal-failure");
+        assert!(classify_distill_error(&terminal).is_transient());
     }
 
     #[test]
-    fn missing_facts_document_parse_failure_is_counted_in_parse_rate() {
-        // Regression for the issues #2622/#2619 path: a missing/empty/unparseable
-        // facts document (process exited 0) MUST classify as parse-failure so it
-        // lands in the distill_parse_success_rate denominator (parse_attempted =
-        // true).
-        let err = SimardError::RpcError(
-            "distill: facts document did not contain a parseable \
-             { \"facts\": [...] } object: launcher banner..."
-                .to_string(),
-        );
+    fn classify_spawn_and_serialize_and_other() {
         assert_eq!(
-            classify_distill_error(&err),
-            DistillFailureClass::ParseFailure
-        );
-        let payload = build_distill_success_context(
-            false,
-            Some(classify_distill_error(&err)),
-            40,
-            0,
-            1,
-            false,
+            classify_distill_error(&SimardError::RpcError(
+                "distill: recipe-runner-rs spawn failed: nope".into()
+            )),
+            DistillFailureClass::SpawnFailure
         );
-        let v: serde_json::Value = serde_json::from_str(&payload).unwrap();
-        assert_eq!(v["parse_attempted"], true);
-        assert_eq!(v["parse_success"], false);
-        assert_eq!(v["failure_class"], "parse-failure");
-    }
-
-    #[test]
-    fn scan_prefers_populated_facts_over_trailing_empty_object() {
-        // A populated facts object followed by an accidental trailing empty
-        // object must NOT silently discard the real facts (data-loss guard).
-        let raw = concat!(
-            r#"{"facts":[{"concept":"lesson-learned","content":"real","source_episode_id":"epi_1"}]}"#,
-            "\n",
-            r#"{"facts":[]}"#
-        );
-        let facts = parse_facts(raw).unwrap();
         assert_eq!(
-            facts.len(),
-            1,
-            "populated object must win over empty trailer"
-        );
-        assert_eq!(facts[0].content, "real");
-    }
-
-    #[test]
-    fn scan_accepts_bare_empty_facts_as_nothing_to_distill() {
-        // A lone `{"facts":[]}` is a legitimate "nothing worth distilling"
-        // answer and must parse to zero facts (not an error).
-        let facts = parse_facts(r#"{"facts":[]}"#).unwrap();
-        assert!(facts.is_empty());
-    }
-}
-
-/// Episode t=9664 (live OODA consolidation): the distill agent intermittently
-/// omits / nulls / scalar-types a single `facts[]` field (most often
-/// `source_episode_id`), which made `serde` reject the **whole** envelope so the
-/// entire batch was silently dropped and re-deferred every cycle. These tests
-/// pin the field-tolerant deserialization ([`de_lenient_string`]) as it applies
-/// to the agent's **facts document** (issues #2622/#2619): one malformed fact no
-/// longer sinks its well-formed siblings, and an ungrounded recovered fact is
-/// still gated by [`assess_fact_reliability`] rather than promoted blindly.
-#[cfg(test)]
-mod issue_t9664_field_tolerance_tests {
-    use super::*;
-
-    /// The headline regression: a facts document in which one fact is
-    /// **well-formed** and a sibling **omits `source_episode_id`**. Before the
-    /// fix the missing field made the whole `{ "facts": [...] }` object
-    /// unparseable and the entire batch was dropped; now the document parses and
-    /// the well-formed fact is recovered.
-    #[test]
-    fn distill_recovers_wellformed_fact_when_sibling_omits_source_episode_id() {
-        let document = "{\"facts\":[\
-               {\"concept\":\"bug-pattern\",\"content\":\"distill parser must tolerate a fact missing source_episode_id\",\"source_episode_id\":\"epi_9664\"},\
-               {\"concept\":\"lesson-learned\",\"content\":\"a sibling fact omitted its source_episode_id\"}\
-             ]}";
-        let out = parse_facts_document(document)
-            .expect("t=9664 document (one field-incomplete fact) must parse");
-        // Both facts are recovered by the parser (the reliability gate, applied
-        // later in the pass, decides promotion vs. quarantine — see
-        // `assess_fact_reliability`). The grounded one is intact.
-        assert!(
-            out.facts.iter().any(|f| f.concept == "bug-pattern"
-                && f.source_episode_id == "epi_9664"
-                && f.content == "distill parser must tolerate a fact missing source_episode_id"),
-            "the well-formed grounded fact must survive a malformed sibling: {:?}",
-            out.facts
+            classify_distill_error(&SimardError::RpcError(
+                "distill: failed to serialize episodes payload: x".into()
+            )),
+            DistillFailureClass::SerializeFailure
         );
-        // The field-incomplete sibling parses with an empty source_episode_id
-        // (ungrounded) rather than poisoning the batch.
-        assert!(
-            out.facts
-                .iter()
-                .any(|f| f.concept == "lesson-learned" && f.source_episode_id.is_empty()),
-            "the field-incomplete sibling must parse with an empty source_episode_id: {:?}",
-            out.facts
-        );
-    }
-
-    /// A bare facts object whose only fact omits `source_episode_id` must parse
-    /// instead of erroring — the minimal reproduction of the schema-strictness
-    /// gap.
-    #[test]
-    fn parse_recipe_output_tolerates_fact_missing_source_episode_id() {
-        let raw = r#"{"facts":[{"concept":"bug-pattern","content":"missing id field"}]}"#;
-        let facts = parse_facts(raw).expect("a fact missing source_episode_id must parse");
-        assert_eq!(facts.len(), 1);
-        assert_eq!(facts[0].concept, "bug-pattern");
-        assert!(facts[0].source_episode_id.is_empty());
-    }
-
-    /// `null` and bare-scalar field values are coerced rather than rejected:
-    /// `source_episode_id: null` and a numeric `source_episode_id` are common
-    /// LLM deviations that previously sank the whole envelope.
-    #[test]
-    fn parse_recipe_output_tolerates_null_and_scalar_fields() {
-        let null_field = r#"{"facts":[{"concept":"lesson-learned","content":"id was null","source_episode_id":null}]}"#;
-        let facts = parse_facts(null_field).expect("null source_episode_id must parse");
-        assert_eq!(facts.len(), 1);
-        assert!(facts[0].source_episode_id.is_empty());
-
-        let numeric_field = r#"{"facts":[{"concept":"pr-pattern","content":"id was numeric","source_episode_id":9664}]}"#;
-        let facts = parse_facts(numeric_field).expect("numeric source_episode_id must parse");
-        assert_eq!(facts.len(), 1);
-        assert_eq!(facts[0].source_episode_id, "9664");
-    }
-
-    /// Field tolerance must NOT weaken quality: a recovered fact whose
-    /// `source_episode_id` does not match any batch episode is ungrounded and
-    /// the reliability gate keeps quarantining it (score < threshold).
-    #[test]
-    fn recovered_fact_with_missing_provenance_is_still_quarantined_by_the_gate() {
-        let ungrounded = DistilledFact {
-            concept: "bug-pattern".to_string(),
-            content: "three or more words present here".to_string(),
-            source_episode_id: String::new(),
-        };
-        let score = assess_fact_reliability(&ungrounded, &[], std::slice::from_ref(&ungrounded));
-        assert!(
-            score < DISTILL_RELIABILITY_THRESHOLD,
-            "ungrounded recovered fact must stay below the promotion threshold, got {score}"
-        );
-    }
-
-    /// Field leniency must not let a trailing *source-less* facts object shadow
-    /// an earlier *grounded* one. Before the grounded-preference tier, the
-    /// source-less object — now parseable thanks to `de_lenient_string` — would
-    /// win as the "last non-empty" object and the earlier attributed fact would
-    /// be silently discarded. The grounded-capable answer must win.
-    #[test]
-    fn grounded_object_wins_over_trailing_sourceless_object() {
-        let step_output = concat!(
-            "{\"facts\":[{\"concept\":\"bug-pattern\",\"content\":\"the attributed answer\",\"source_episode_id\":\"epi_1\"}]}\n",
-            "{\"facts\":[{\"concept\":\"bug-pattern\",\"content\":\"a later source-less restatement\"}]}"
-        );
-        let facts = parse_facts(step_output).expect("a grounded object must be recoverable");
         assert_eq!(
-            facts.len(),
-            1,
-            "exactly the grounded object's facts: {facts:?}"
+            classify_distill_error(&SimardError::RpcError("backend blew up".into())),
+            DistillFailureClass::Other
         );
-        assert_eq!(facts[0].source_episode_id, "epi_1");
-        assert_eq!(facts[0].content, "the attributed answer");
     }
 
-    /// A non-scalar (array/object) value for a promised-string field collapses to
-    /// empty rather than being stringified, so it cannot smuggle structured JSON
-    /// text past the empty-content / known-concept gates. The envelope still
-    /// parses (the batch is not dropped); the malformed fact is simply gateable.
     #[test]
-    fn non_scalar_field_values_collapse_to_empty() {
-        let raw = r#"{"facts":[{"concept":"bug-pattern","content":["a","b"],"source_episode_id":{"x":1}}]}"#;
-        let facts = parse_facts(raw).expect("non-scalar fields must not sink the envelope");
-        assert_eq!(facts.len(), 1);
-        assert!(
-            facts[0].content.is_empty(),
-            "array content must collapse to empty, got {:?}",
-            facts[0].content
-        );
-        assert!(
-            facts[0].source_episode_id.is_empty(),
-            "object source_episode_id must collapse to empty, got {:?}",
-            facts[0].source_episode_id
-        );
-        // Empty content → reliability hard gate quarantines it (score 0.0).
-        let score = assess_fact_reliability(&facts[0], &[], &facts);
-        assert_eq!(score, 0.0, "empty-content fact must score 0.0");
-    }
-}
-
-/// Issues #2622/#2619 — the distill result is read from a dedicated **facts
-/// file** the agent writes, never from recipe-runner stdout. These tests pin
-/// the two structural guarantees of that fix:
-///
-/// 1. The copilot launcher banner / log lines on stdout can NEVER contaminate
-///    the parse — a valid facts file yields facts even when stdout is pure
-///    launcher noise (the exact live failure shape from daemon logs 02:45–02:47).
-/// 2. There is NO silent stdout fallback — a missing facts file is an explicit,
-///    retry-eligible parse failure even when stdout happens to carry a
-///    well-formed `{ "facts": [...] }` object.
-#[cfg(test)]
-mod issue_2622_file_channel_tests {
-    use super::*;
-
-    /// The launcher banner captured live (daemon logs 02:45–02:47, Copilot CLI
-    /// 1.0.69-1) that was previously captured AS the distill step output and
-    /// scraped for facts — matching the banner, never the answer.
-    const LIVE_LAUNCHER_BANNER: &str = "2026-07-06T02:45:12.101010Z  INFO launching copilot \
-         binary=/home/azureuser/.npm-global/bin/copilot version=\"GitHub Copilot CLI 1.0.69-1.\"\n\
-         \u{2139} NODE_OPTIONS=--max-old-space-size=32768 (saved preference)\n\
-         Run 'copilot update' to update\n";
-
-    #[cfg(unix)]
-    fn output_with(stdout: &[u8], code: i32) -> std::process::Output {
+    fn interpret_exit_zero_is_ok_regardless_of_stdout() {
         use std::os::unix::process::ExitStatusExt;
-        std::process::Output {
-            status: std::process::ExitStatus::from_raw(code << 8),
-            stdout: stdout.to_vec(),
+        let output = std::process::Output {
+            status: std::process::ExitStatus::from_raw(0),
+            stdout: b"{\"facts\":[{\"a\":1},],}\x1b[0m noisy banner".to_vec(),
             stderr: Vec::new(),
-        }
-    }
-
-    /// The headline regression: the runner's stdout is nothing but the copilot
-    /// launcher banner, yet the agent wrote a clean facts envelope to the
-    /// dedicated file — the pass MUST succeed and yield the facts (no
-    /// parse-failure). This is the exact contamination shape from issues
-    /// #2622/#2619.
-    #[cfg(unix)]
-    #[test]
-    fn launcher_banner_on_stdout_does_not_cause_parse_failure() {
-        let dir = tempfile::tempdir().unwrap();
-        let facts_path = dir.path().join("facts.json");
-        std::fs::write(
-            &facts_path,
-            r#"{"facts":[{"concept":"pr-pattern","content":"warm the shared cache before lbug pin bumps","source_episode_id":"epi_1"}],"procedures":[]}"#,
-        )
-        .unwrap();
-
-        let output = output_with(LIVE_LAUNCHER_BANNER.as_bytes(), 0);
-        let document = harvest_facts_file(&output, &facts_path)
-            .expect("a launcher banner on stdout must NOT block reading the facts file");
-        let out = parse_facts_document(&document).expect("the clean facts file must parse");
-        assert_eq!(out.facts.len(), 1);
-        assert_eq!(out.facts[0].concept, "pr-pattern");
-        assert_eq!(out.facts[0].source_episode_id, "epi_1");
-    }
-
-    /// No silent fallback: a missing facts file is an explicit `ParseFailure`
-    /// even when stdout carries a perfectly well-formed facts object — proving
-    /// stdout is never scraped as a fallback result channel.
-    #[cfg(unix)]
-    #[test]
-    fn missing_facts_file_is_parse_failure_never_stdout_fallback() {
-        let dir = tempfile::tempdir().unwrap();
-        let facts_path = dir.path().join("facts.json"); // deliberately never written
-
-        let tempting_stdout =
-            br#"{"facts":[{"concept":"pr-pattern","content":"must be ignored","source_episode_id":"epi_9"}]}"#;
-        let output = output_with(tempting_stdout, 0);
-        let err = harvest_facts_file(&output, &facts_path)
-            .expect_err("a missing facts file must be an explicit error, never a stdout fallback");
-        assert_eq!(
-            classify_distill_error(&err),
-            DistillFailureClass::ParseFailure
-        );
+        };
+        assert!(interpret_recipe_exit(&output).is_ok());
     }
 
-    /// A non-zero recipe exit is surfaced as an explicit terminal failure that
-    /// carries the stdout/stderr context — never a silent success.
-    #[cfg(unix)]
     #[test]
-    fn nonzero_exit_is_terminal_failure_with_context() {
-        let dir = tempfile::tempdir().unwrap();
-        let facts_path = dir.path().join("facts.json");
-        let output = output_with(b"boom on stdout", 3);
-        let err = harvest_facts_file(&output, &facts_path)
-            .expect_err("a non-zero exit must surface an explicit error");
+    fn interpret_nonzero_exit_is_terminal_error() {
+        use std::os::unix::process::ExitStatusExt;
+        let output = std::process::Output {
+            status: std::process::ExitStatus::from_raw(1 << 8),
+            stdout: Vec::new(),
+            stderr: b"boom".to_vec(),
+        };
+        let err = interpret_recipe_exit(&output).expect_err("nonzero exit must error");
         assert_eq!(
             classify_distill_error(&err),
             DistillFailureClass::CopilotTerminalFailure
         );
     }
-
-    /// A clean, exit-0 run whose facts file carries a valid envelope is read
-    /// verbatim from the file.
-    #[cfg(unix)]
-    #[test]
-    fn clean_run_reads_facts_verbatim_from_file() {
-        let dir = tempfile::tempdir().unwrap();
-        let facts_path = dir.path().join("facts.json");
-        std::fs::write(&facts_path, r#"{"facts":[],"procedures":[]}"#).unwrap();
-        let output = output_with(b"", 0);
-        let document = harvest_facts_file(&output, &facts_path).expect("clean run must read file");
-        let out = parse_facts_document(&document).expect("an empty envelope is a valid success");
-        assert!(out.facts.is_empty() && out.procedures.is_empty());
-    }
-
-    /// An empty facts document (the agent created the file but wrote nothing) is
-    /// an explicit parse failure — never a hollow `Ok`.
-    #[test]
-    fn empty_facts_document_is_parse_failure() {
-        let err = parse_facts_document("   \n\t ")
-            .expect_err("an empty facts document must be an explicit error");
-        assert_eq!(
-            classify_distill_error(&err),
-            DistillFailureClass::ParseFailure
-        );
-    }
-
-    /// A launcher banner written INTO the file (no JSON object at all) still
-    /// fails explicitly — `parse_facts_document` does not scrape a banner for a
-    /// `{ "facts": [...] }` object.
-    #[test]
-    fn banner_only_document_is_parse_failure() {
-        let err = parse_facts_document(LIVE_LAUNCHER_BANNER)
-            .expect_err("a banner-only document has no facts object and must error");
-        assert_eq!(
-            classify_distill_error(&err),
-            DistillFailureClass::ParseFailure
-        );
-    }
-
-    /// The agent may wrap its answer in a Markdown code fence inside the file;
-    /// the facts must still be recovered (clean-channel format leniency).
-    #[test]
-    fn fenced_facts_document_still_parses() {
-        let fenced = "```json\n{\"facts\":[{\"concept\":\"bug-pattern\",\"content\":\"off-by-one in the ring buffer\",\"source_episode_id\":\"epi_7\"}],\"procedures\":[]}\n```";
-        let out = parse_facts_document(fenced).expect("a fenced facts document must still parse");
-        assert_eq!(out.facts.len(), 1);
-        assert_eq!(out.facts[0].source_episode_id, "epi_7");
-    }
 }
diff --git a/src/memory_consolidation/distillation_fact_yield_bench.rs b/src/memory_consolidation/distillation_fact_yield_bench.rs
deleted file mode 100644
index 797cc4d2..00000000
--- a/src/memory_consolidation/distillation_fact_yield_bench.rs
+++ /dev/null
@@ -1,412 +0,0 @@
-//! Deterministic **fact-yield benchmark** for episode distillation (perpetual
-//! cognition sub-goal: *raise distillation fact-yield*).
-//!
-//! ## What this measures — and what it does NOT claim
-//!
-//! This is a **deterministic regression benchmark**, not an estimate of
-//! real-world LLM yield. It measures the *parse + reliability-gate* fact-yield —
-//! surviving facts per input episode — over a **fixed, hand-authored sample
-//! corpus**. It exercises the deterministic portion of a distillation pass,
-//! everything downstream of the (non-deterministic) LLM recipe call:
-//!
-//! 1. `parse_facts_document` — parses the recipe's JSON envelope and applies
-//!    the concept filter ([`RecipeEnvelope::into_facts`]).
-//! 2. the ISAO reliability gate — [`assess_fact_reliability`] against
-//!    [`DISTILL_RELIABILITY_THRESHOLD`].
-//!
-//! The numbers are a property of this corpus (which deliberately contains five
-//! recoverable surface-form-variant labels), NOT a measurement of how often
-//! concept-variant drops occur in production. Treat `baseline_yield=0.120 →
-//! improved_yield=0.320` as "the concept filter no longer drops these five
-//! legitimate facts", not as a global production-yield delta.
-//!
-//! The corpus is deliberately **dedup-neutral against an empty store** (every
-//! candidate has distinct `concept + content`), so the production dedup guard —
-//! which only blocks an equal-or-stronger *identical* prior — never fires. The
-//! parse+gate survivor count therefore equals the full-pass promoted count for a
-//! FRESH memory; that equality is not merely asserted here but *exercised* by
-//! [`distillation_tests::full_pass_promotes_canonicalized_surface_variants_through_dedup`],
-//! which routes this same corpus through the real
-//! `distill_recent_episodes_with_runner` (parse → gate → dedup guard → store)
-//! and confirms all eight survive.
-//!
-//! ## `structural_precision`, not semantic truth
-//!
-//! Precision here is **structural**: a promoted fact is "correct" iff it is
-//! grounded in the batch, non-empty, and carries a recognized concept — exactly
-//! the reliability gate's admission invariant. It does NOT assert the fact's
-//! content is semantically supported by the cited episode (the gate never claimed
-//! to). The point this benchmark proves is narrow but real: canonicalization does
-//! not *weaken* that structural invariant — it admits only facts the gate would
-//! already accept had the label been spelled canonically, and never an off-spec,
-//! ungrounded, or empty candidate.
-//!
-//! ## Baseline vs improved (self-contained before/after)
-//!
-//! The benchmark computes two numbers over the SAME corpus:
-//!
-//! * **baseline** — an in-test oracle that replicates the *legacy exact-match*
-//!   concept filter (`concept == "pr-pattern" | "bug-pattern" | "lesson-learned"`).
-//! * **improved** — the REAL production path (`parse_facts_document`), which
-//!   now canonicalizes surface-form concept variants before the filter.
-//!
-//! It asserts the improved path promotes strictly more facts than the baseline
-//! (higher parse+gate yield) while keeping **structural_precision at 1.0** and
-//! never dropping a fact the baseline kept (superset). If the canonicalization is
-//! reverted, `improved` collapses to `baseline` and the strict-improvement
-//! assertion fails — the permanent regression guard.
-
-use crate::memory_cognitive::CognitiveEpisode;
-use crate::memory_consolidation::distillation::{
-    DISTILL_RELIABILITY_THRESHOLD, DistilledFact, KNOWN_DISTILL_CONCEPTS, assess_fact_reliability,
-    parse_facts_document,
-};
-
-/// Number of episodes in the fixed consolidation-input batch.
-pub(crate) const CORPUS_EPISODE_COUNT: usize = 25;
-
-/// Parse+gate survivor count under the legacy exact-match concept filter. This
-/// is the **recorded baseline** the improvement is measured against.
-pub(crate) const BASELINE_PROMOTED: usize = 3;
-
-/// Parse+gate survivor count under the canonicalizing concept filter (the
-/// shipped change). Recovers the five surface-form-variant facts the exact-match
-/// filter silently dropped. The full-pass test
-/// `distillation_tests::full_pass_promotes_canonicalized_surface_variants_through_dedup`
-/// confirms all eight are actually promoted (survive the dedup guard + storage).
-pub(crate) const IMPROVED_PROMOTED: usize = 8;
-
-/// Build the fixed episode batch: ids `ep-000`..`ep-024`. Grounding is decided
-/// purely by whether a fact cites one of these ids.
-fn corpus_episodes() -> Vec<CognitiveEpisode> {
-    (0..CORPUS_EPISODE_COUNT)
-        .map(|i| CognitiveEpisode {
-            node_id: format!("ep-{i:03}"),
-            content: format!("episode {i} body"),
-            source_label: "distill-bench".to_string(),
-            temporal_index: i as i64,
-            compressed: false,
-        })
-        .collect()
-}
-
-/// The fixed recipe-output envelope (a stand-in for one LLM distillation
-/// response), shared with the full-pass test in `distillation_tests` so both
-/// measure the identical corpus. Thirteen candidate facts spanning every
-/// yield/precision case:
-///
-/// * 3 canonical, grounded, well-formed — kept by BOTH filters.
-/// * 5 surface-form variants (case / whitespace / underscore), grounded,
-///   well-formed — dropped by the exact-match filter, RECOVERED by
-///   canonicalization. This is the yield gain.
-/// * 3 genuinely off-spec concepts — dropped by BOTH (precision guard: the
-///   canonicalizer must NOT admit these).
-/// * 1 canonical concept but ungrounded provenance — passes both filters, then
-///   quarantined by the reliability gate (precision guard).
-/// * 1 canonical concept but empty content — passes both filters, then
-///   quarantined by the reliability hard gate (precision guard).
-pub(crate) const CORPUS_RECIPE_JSON: &str = r#"{"facts":[
-  {"concept":"pr-pattern","content":"rebase feature branches before merging to keep history linear","source_episode_id":"ep-000"},
-  {"concept":"bug-pattern","content":"null dereference when the input batch is empty","source_episode_id":"ep-001"},
-  {"concept":"lesson-learned","content":"write the failing parser test before touching the scanner","source_episode_id":"ep-002"},
-  {"concept":"PR-Pattern","content":"squash fixups so each commit builds green","source_episode_id":"ep-003"},
-  {"concept":" bug-pattern ","content":"off by one on the last chunk boundary","source_episode_id":"ep-004"},
-  {"concept":"Lesson-Learned","content":"measure before optimizing the hot path","source_episode_id":"ep-005"},
-  {"concept":"pr_pattern","content":"request review from the module owner","source_episode_id":"ep-006"},
-  {"concept":"BUG-PATTERN","content":"unbounded retry loop on transient network error","source_episode_id":"ep-007"},
-  {"concept":"made-up-label","content":"this concept is off spec and must be dropped","source_episode_id":"ep-008"},
-  {"concept":"skip","content":"no durable signal in this episode","source_episode_id":"ep-009"},
-  {"concept":"observation","content":"random unstructured note with no label","source_episode_id":"ep-010"},
-  {"concept":"pr-pattern","content":"cites an episode outside this batch so provenance is unverifiable","source_episode_id":"ep-999"},
-  {"concept":"bug-pattern","content":"   ","source_episode_id":"ep-011"}
-]}"#;
-
-/// A parsed candidate fact straight from the recipe JSON, BEFORE any concept
-/// filtering — the raw material the baseline oracle filters itself.
-struct RawCandidate {
-    concept: String,
-    content: String,
-    source_episode_id: String,
-}
-
-/// Parse `CORPUS_RECIPE_JSON` into raw candidates without applying any concept
-/// filter. Used only by the baseline oracle so it can replicate the *legacy*
-/// exact-match behaviour independently of the production parser.
-fn raw_candidates() -> Vec<RawCandidate> {
-    let v: serde_json::Value =
-        serde_json::from_str(CORPUS_RECIPE_JSON).expect("benchmark corpus JSON must be valid");
-    v["facts"]
-        .as_array()
-        .expect("corpus must have a facts array")
-        .iter()
-        .map(|f| RawCandidate {
-            concept: f["concept"].as_str().unwrap_or_default().to_string(),
-            content: f["content"].as_str().unwrap_or_default().to_string(),
-            source_episode_id: f["source_episode_id"]
-                .as_str()
-                .unwrap_or_default()
-                .to_string(),
-        })
-        .collect()
-}
-
-/// The reliability gate: keep only facts whose self-assessed confidence clears
-/// [`DISTILL_RELIABILITY_THRESHOLD`]. This is the exact promotion predicate the
-/// production pass applies (minus the dedup guard, which the dedup-neutral
-/// corpus never triggers).
-fn gate_survivors(facts: &[DistilledFact], episodes: &[CognitiveEpisode]) -> Vec<DistilledFact> {
-    facts
-        .iter()
-        .filter(|f| assess_fact_reliability(f, episodes, facts) >= DISTILL_RELIABILITY_THRESHOLD)
-        .cloned()
-        .collect()
-}
-
-/// Legacy baseline oracle: replicate the *exact-match* concept filter that
-/// `into_facts` used before canonicalization, then gate. Independent of the
-/// production parser so the before/after comparison is honest.
-fn baseline_promoted(episodes: &[CognitiveEpisode]) -> Vec<DistilledFact> {
-    let filtered: Vec<DistilledFact> = raw_candidates()
-        .into_iter()
-        .filter(|c| {
-            matches!(
-                c.concept.as_str(),
-                "pr-pattern" | "bug-pattern" | "lesson-learned"
-            )
-        })
-        .map(|c| DistilledFact {
-            concept: c.concept,
-            content: c.content,
-            source_episode_id: c.source_episode_id,
-        })
-        .collect();
-    gate_survivors(&filtered, episodes)
-}
-
-/// Improved path: the REAL production parse+filter (`parse_facts_document`,
-/// which now canonicalizes concepts), then the same gate.
-fn improved_promoted(episodes: &[CognitiveEpisode]) -> Vec<DistilledFact> {
-    let output = parse_facts_document(CORPUS_RECIPE_JSON)
-        .expect("benchmark corpus must parse into a facts object");
-    gate_survivors(&output.facts, episodes)
-}
-
-/// A promoted fact is "structurally correct" iff it is grounded in the batch,
-/// has non-empty content, and carries a recognized concept label — exactly the
-/// reliability gate's admission invariant. This is a STRUCTURAL check, not a
-/// judgement that the fact's content is semantically supported by the cited
-/// episode; the point is that canonicalization does not weaken the invariant.
-fn is_correct(fact: &DistilledFact, episodes: &[CognitiveEpisode]) -> bool {
-    let grounded = episodes.iter().any(|e| e.node_id == fact.source_episode_id);
-    let non_empty = !fact.content.trim().is_empty();
-    let known_concept = KNOWN_DISTILL_CONCEPTS
-        .iter()
-        .any(|c| c.eq_ignore_ascii_case(fact.concept.trim()));
-    grounded && non_empty && known_concept
-}
-
-/// Structural precision: fraction of promoted facts that satisfy the gate's
-/// structural admission invariant (see [`is_correct`]). 1.0 means the promotion
-/// set contains no ungrounded, empty, or off-spec fact.
-fn structural_precision(promoted: &[DistilledFact], episodes: &[CognitiveEpisode]) -> f64 {
-    if promoted.is_empty() {
-        return 1.0;
-    }
-    let correct = promoted.iter().filter(|f| is_correct(f, episodes)).count();
-    correct as f64 / promoted.len() as f64
-}
-
-#[test]
-fn fact_yield_benchmark_records_baseline_and_proves_improvement() {
-    let episodes = corpus_episodes();
-
-    let baseline = baseline_promoted(&episodes);
-    let improved = improved_promoted(&episodes);
-
-    let baseline_yield = baseline.len() as f64 / episodes.len() as f64;
-    let improved_yield = improved.len() as f64 / episodes.len() as f64;
-    let baseline_structural_precision = structural_precision(&baseline, &episodes);
-    let improved_structural_precision = structural_precision(&improved, &episodes);
-
-    // Emit the recorded numbers so CI logs (`-- --nocapture`) show the baseline
-    // and the measured improvement on every run. These are parse+gate survivor
-    // counts over the FIXED corpus, not a real-world end-to-end LLM yield.
-    println!(
-        "[fact-yield-bench] corpus_episodes={} candidate_facts={} \
-         baseline_promoted={} improved_promoted={} \
-         baseline_yield={:.3} improved_yield={:.3} \
-         baseline_structural_precision={:.3} improved_structural_precision={:.3}",
-        episodes.len(),
-        raw_candidates().len(),
-        baseline.len(),
-        improved.len(),
-        baseline_yield,
-        improved_yield,
-        baseline_structural_precision,
-        improved_structural_precision,
-    );
-
-    // 1. Recorded baseline is stable.
-    assert_eq!(
-        baseline.len(),
-        BASELINE_PROMOTED,
-        "recorded baseline fact-yield drifted; corpus or exact-match oracle changed"
-    );
-
-    // 2. The shipped change raises measured yield to the recorded improved number.
-    assert_eq!(
-        improved.len(),
-        IMPROVED_PROMOTED,
-        "improved fact-yield drifted from the recorded number"
-    );
-
-    // 3. Yield strictly improved (the core acceptance signal). Reverting the
-    //    concept canonicalization makes `improved == baseline` and fails here.
-    assert!(
-        improved.len() > baseline.len(),
-        "fact-yield did not improve: improved={} baseline={}",
-        improved.len(),
-        baseline.len()
-    );
-
-    // 4. Structural precision is NOT lowered — both paths promote only facts that
-    //    satisfy the gate's grounded/non-empty/known-concept invariant.
-    assert_eq!(
-        baseline_structural_precision, 1.0,
-        "baseline structural precision must be 1.0"
-    );
-    assert_eq!(
-        improved_structural_precision, 1.0,
-        "improved structural precision regressed below 1.0 — canonicalization admitted an off-spec/ungrounded/empty fact"
-    );
-    assert!(
-        improved_structural_precision >= baseline_structural_precision,
-        "structural precision regressed: improved={improved_structural_precision} baseline={baseline_structural_precision}"
-    );
-
-    // 5. No regression: every fact the baseline promoted is still promoted.
-    for b in &baseline {
-        assert!(
-            improved
-                .iter()
-                .any(|i| i.content == b.content && i.source_episode_id == b.source_episode_id),
-            "improved path dropped a baseline-promoted fact: {b:?}"
-        );
-    }
-}
-
-#[test]
-fn fact_yield_benchmark_recovers_only_surface_variants_not_offspec() {
-    // The five recovered facts (improved − baseline) must all be the grounded,
-    // well-formed, surface-variant-concept facts — never an off-spec, ungrounded,
-    // or empty candidate. This pins that the yield gain is precision-safe.
-    let episodes = corpus_episodes();
-    let baseline = baseline_promoted(&episodes);
-    let improved = improved_promoted(&episodes);
-
-    let recovered: Vec<&DistilledFact> = improved
-        .iter()
-        .filter(|i| {
-            !baseline
-                .iter()
-                .any(|b| b.content == i.content && b.source_episode_id == i.source_episode_id)
-        })
-        .collect();
-
-    assert_eq!(
-        recovered.len(),
-        IMPROVED_PROMOTED - BASELINE_PROMOTED,
-        "unexpected number of recovered facts"
-    );
-    for r in recovered {
-        assert!(
-            is_correct(r, &episodes),
-            "a recovered fact is not a correct (grounded/non-empty/known-concept) fact: {r:?}"
-        );
-        // Every promoted concept is stored in canonical (lower-hyphen) form.
-        assert!(
-            matches!(
-                r.concept.as_str(),
-                "pr-pattern" | "bug-pattern" | "lesson-learned"
-            ),
-            "recovered fact concept was not canonicalized: {:?}",
-            r.concept
-        );
-    }
-}
-
-/// Deterministic **before/after parse-recovery benchmark** for issue #2658.
-///
-/// A single trailing comma in the distiller agent's JSON (the most common LLM
-/// JSON defect) made strict `serde_json` reject the WHOLE facts object, so the
-/// batch was deferred every cycle and `distill_parse_success_rate` collapsed
-/// toward 0 (the overseer's "residual 100% parse-failure"). Over a batch of
-/// trailing-comma documents reproducing that shape, the strict baseline fails
-/// EVERY one (parse-failure-rate = 1.000) while the shipped tolerant parser
-/// (`parse_facts_document`, the real production path) recovers EVERY one
-/// (parse-failure-rate = 0.000).
-///
-/// This is the deterministic, in-process analog of the live
-/// `distill_parse_success_rate` self-metric, which
-/// `record_parse_outcome("distill", parsed.is_ok())` drives from the same
-/// `parse_facts_document` return value on every real pass — so a production
-/// distill pass over trailing-comma output moves that metric off the floor by
-/// the exact mechanism proven here.
-#[test]
-fn distill_parse_failure_rate_benchmark_before_1000_after_0000() {
-    // A batch of realistic trailing-comma distill facts documents (bare and
-    // pretty-printed) that each carry one well-formed, grounded fact.
-    let doc = |ep: &str, pretty: bool| -> String {
-        if pretty {
-            format!(
-                "{{\n  \"facts\": [\n    {{\"concept\": \"lesson-learned\", \"content\": \"c\", \"source_episode_id\": \"{ep}\"}},\n  ],\n}}"
-            )
-        } else {
-            format!(
-                "{{\"facts\":[{{\"concept\":\"pr-pattern\",\"content\":\"c\",\"source_episode_id\":\"{ep}\"}},],}}"
-            )
-        }
-    };
-    let batch: Vec<String> = vec![
-        doc("epi_1", false),
-        doc("epi_2", true),
-        doc("epi_3", false),
-        doc("epi_4", true),
-        doc("epi_5", false),
-    ];
-    let n = batch.len() as f64;
-
-    // BEFORE — the strict baseline (what the pre-#2658 parser effectively did:
-    // reject the whole facts object on any trailing comma). Every one fails.
-    let before_failures = batch
-        .iter()
-        .filter(|raw| serde_json::from_str::<serde_json::Value>(raw).is_err())
-        .count();
-    let before_failure_rate = before_failures as f64 / n;
-
-    // AFTER — the shipped tolerant parser on the real production entry point.
-    let after_failures = batch
-        .iter()
-        .filter(|raw| {
-            parse_facts_document(raw)
-                .map(|o| o.facts.is_empty())
-                .unwrap_or(true)
-        })
-        .count();
-    let after_failure_rate = after_failures as f64 / n;
-
-    println!(
-        "[distill-parse-recovery-bench #2658] batch={} before_failure_rate={before_failure_rate:.3} \
-         after_failure_rate={after_failure_rate:.3}",
-        batch.len()
-    );
-
-    assert_eq!(
-        before_failure_rate, 1.000,
-        "baseline strict parse must fail EVERY trailing-comma document (the residual 100% shape)"
-    );
-    assert_eq!(
-        after_failure_rate, 0.000,
-        "the tolerant parser must recover EVERY trailing-comma document (fact-yield restored)"
-    );
-}
diff --git a/src/memory_consolidation/distillation_semantic_handoff_tests.rs b/src/memory_consolidation/distillation_semantic_handoff_tests.rs
new file mode 100644
index 00000000..ca09baed
--- /dev/null
+++ b/src/memory_consolidation/distillation_semantic_handoff_tests.rs
@@ -0,0 +1,349 @@
+//! TDD (RED) tests for the #2679 semantic agent→agent handoff in the
+//! distillation RESULT path.
+//!
+//! ## What #2679 changes
+//!
+//! Before: the distiller agent printed a `{ "facts": [...] }` envelope; Simard
+//! scraped it back out of noisy recipe stdout (launcher banner + ANSI + tracing
+//! lines) via `extract_json_payload` → `balanced_objects` →
+//! `serde_json::from_str`, and a single malformed token (a trailing comma)
+//! failed the strict parse and discarded the ENTIRE batch — the
+//! `parse_fail` / 91%→100% failure mode.
+//!
+//! After: the distiller agentic step writes each fact DIRECTLY through the
+//! gated cognitive-memory write boundary during its run. There is **no return
+//! payload for Simard to parse**. The two seams that reach the boundary — the
+//! IPC server (real subprocess path) and the in-process `DistillFactSink` (test
+//! stubs) — share the `crate::fact_reliability` gate, so a fact scores and
+//! stores identically no matter which commits it.
+//!
+//! These tests pin:
+//!   * **SEC-T6 (headline):** a finished recipe run is interpreted by exit
+//!     status ALONE — `interpret_recipe_exit` never reads stdout, so noisy /
+//!     trailing-comma / banner-polluted stdout can no longer fail the pipeline
+//!     (there is no parse to fail).
+//!   * the agentic pipeline commits grounded facts to memory and marks every
+//!     episode, using a run-only stub UNCHANGED (additive-trait contract), and
+//!   * the in-process sink applies the SAME reliability gate (ungrounded /
+//!     empty content quarantined), and
+//!   * retry-safety: an erroring agentic step leaves the batch fully unmarked.
+//!
+//! They reference `interpret_recipe_exit` (which replaces the removed
+//! `harvest_facts_file` + `parse_facts*` machinery) and the additive
+//! `run_agentic` handoff; those do not exist yet — the intended TDD red signal.
+//!
+//! NOTE: the legacy strict-parse / trailing-comma / field-tolerance unit tests
+//! in `distillation.rs` and the file-channel stub tests are RETIRED by #2679
+//! (they assert a parse that no longer exists). This module is their
+//! replacement: it proves the failure mode is now *structurally impossible*
+//! rather than merely tolerated.
+
+use std::os::unix::process::ExitStatusExt;
+use std::process::{ExitStatus, Output};
+use std::sync::atomic::{AtomicU32, Ordering};
+
+use crate::cognitive_memory::{CognitiveMemoryOps, LibraryCognitiveMemory};
+use crate::error::{SimardError, SimardResult};
+use crate::memory_cognitive::CognitiveEpisode;
+use crate::memory_consolidation::distillation::{
+    DISTILL_MIN_EPISODES, DistillRecipeRunner, DistilledFact, distill_recent_episodes_with_runner,
+    interpret_recipe_exit,
+};
+
+// ───────────────────────────────────────────────────────────────────────────
+// Helpers
+// ───────────────────────────────────────────────────────────────────────────
+
+/// A finished subprocess `Output` with the given exit code and stdout. The
+/// stderr is left empty; the point of #2679 is that NEITHER stream is parsed
+/// for facts.
+fn output_with(code: i32, stdout: &str) -> Output {
+    Output {
+        // On Unix, a normal exit with code `c` is wait-status `c << 8`.
+        status: ExitStatus::from_raw(code << 8),
+        stdout: stdout.as_bytes().to_vec(),
+        stderr: Vec::new(),
+    }
+}
+
+/// Seed `n` undistilled episodes into a fresh in-memory library store and
+/// return the store. The distiller's facts cite these episodes' ids, so they
+/// are grounded by batch membership.
+fn store_with_episodes(n: usize) -> LibraryCognitiveMemory {
+    let mem = LibraryCognitiveMemory::in_memory().expect("in-memory db");
+    for i in 0..n {
+        mem.store_episode(
+            &format!("episode payload number {i}"),
+            "engineer-cycle",
+            None,
+        )
+        .expect("store_episode");
+    }
+    mem
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// SEC-T6 (headline): the result path is an exit-status check — stdout is NEVER
+// parsed, so noisy / trailing-comma stdout can no longer fail the pipeline.
+// ───────────────────────────────────────────────────────────────────────────
+
+/// The single most important regression for #2679/#2658: a recipe that exits 0
+/// while emitting the copilot launcher banner, ANSI colour codes, tracing log
+/// lines, AND a *trailing-comma-malformed* `{ "facts": [...] , }` object on
+/// stdout must be interpreted as SUCCESS. The old code scraped this stdout and
+/// the trailing comma failed `serde_json::from_str`, discarding the batch. The
+/// new code never reads stdout for facts — so there is no parse to fail.
+#[test]
+fn sec_t6_noisy_trailing_comma_stdout_is_not_parsed_and_does_not_fail() {
+    let noisy = concat!(
+        // launcher banner
+        "2026-07-06T09:00:00.000000Z  INFO launching copilot binary=copilot ",
+        "version=\"GitHub Copilot CLI 1.0.69-2\"\n",
+        // saved-preference notice with a unicode glyph
+        "\u{2139} NODE_OPTIONS=--max-old-space-size=32768 (saved preference)\n",
+        // an ANSI-coloured tracing line
+        "\u{1b}[32m INFO\u{1b}[0m recipe-runner: step 'distill' completed\n",
+        // a MALFORMED facts object with trailing commas after the fact and array
+        "{\"facts\":[{\"concept\":\"pr-pattern\",\"content\":\"warm cache before pin bumps\",",
+        "\"source_episode_id\":\"epi_1\"},],}\n",
+        "Run 'copilot update' to update\n",
+    );
+    // Precondition: this stdout is NOT valid JSON — the old strict parse died here.
+    assert!(
+        serde_json::from_str::<serde_json::Value>(noisy).is_err(),
+        "precondition: the noisy trailing-comma stdout must be strict-invalid JSON"
+    );
+
+    let result = interpret_recipe_exit(&output_with(0, noisy));
+    assert!(
+        result.is_ok(),
+        "an exit-0 recipe run must succeed regardless of stdout content — there is no parse to \
+         fail post-#2679; got {result:?}"
+    );
+}
+
+/// A clean exit-0 run with EMPTY stdout is also success: the agent committed its
+/// facts through the write boundary, so an empty terminal is expected, not an
+/// error (the old "facts document was empty" parse-failure is gone).
+#[test]
+fn sec_t6_empty_stdout_on_exit_zero_is_success_not_parse_failure() {
+    assert!(
+        interpret_recipe_exit(&output_with(0, "")).is_ok(),
+        "empty stdout on a clean exit must not be a failure — the result is in memory, not stdout"
+    );
+}
+
+/// A non-zero exit is still a real, surfaced failure (the recipe process itself
+/// broke) — this is the only failure the result path can report now. It must
+/// carry context and must NOT be a silent success.
+#[test]
+fn nonzero_exit_is_a_surfaced_terminal_failure() {
+    let err = interpret_recipe_exit(&output_with(1, "some diagnostic on stdout"))
+        .expect_err("a non-zero recipe exit must surface an error");
+    match err {
+        SimardError::RpcError(msg) => assert!(
+            msg.contains("distill") && msg.contains("exited"),
+            "terminal-failure message must name the distill recipe and the non-zero exit: {msg}"
+        ),
+        other => panic!("expected RpcError terminal failure, got {other:?}"),
+    }
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Agentic pipeline: a run-only stub commits grounded facts via the sink and
+// every episode is marked — additive-trait contract (stub UNCHANGED).
+// ───────────────────────────────────────────────────────────────────────────
+
+/// A deterministic stub that implements ONLY the legacy `run` (returning facts).
+/// It must keep working unchanged: the new default `run_agentic` bridges its
+/// returned facts to the in-process gated `DistillFactSink`. Each fact cites a
+/// real batch episode id so it is grounded.
+struct GroundedFactsRunner {
+    calls: AtomicU32,
+}
+
+impl DistillRecipeRunner for GroundedFactsRunner {
+    fn run(&self, episodes: &[CognitiveEpisode]) -> SimardResult<Vec<DistilledFact>> {
+        self.calls.fetch_add(1, Ordering::SeqCst);
+        Ok(vec![
+            DistilledFact {
+                concept: "bug-pattern".into(),
+                content: "empty outcome list panics cycle".into(),
+                source_episode_id: episodes[0].node_id.clone(),
+            },
+            DistilledFact {
+                concept: "lesson-learned".into(),
+                content: "prefer keyword overlap for episodic recall".into(),
+                source_episode_id: episodes[1].node_id.clone(),
+            },
+        ])
+    }
+}
+
+#[test]
+fn agentic_pass_commits_grounded_facts_and_marks_every_episode() {
+    let n = DISTILL_MIN_EPISODES as usize + 2;
+    let mem = store_with_episodes(n);
+    let runner = GroundedFactsRunner {
+        calls: AtomicU32::new(0),
+    };
+
+    let report = distill_recent_episodes_with_runner(&mem as &dyn CognitiveMemoryOps, &runner)
+        .expect("agentic pass must succeed");
+
+    assert!(!report.was_skipped(), "above-threshold pass must run");
+    assert_eq!(
+        runner.calls.load(Ordering::SeqCst),
+        1,
+        "the runner must be invoked exactly once per pass"
+    );
+    assert_eq!(
+        report.fact_count, 2,
+        "both grounded, well-formed facts must be committed"
+    );
+    assert_eq!(
+        report.marked_count as usize, n,
+        "every input episode must be marked distilled (replay guard)"
+    );
+
+    // The facts really reached semantic memory — via the write boundary, with no
+    // envelope parsed anywhere.
+    let bugs = mem
+        .search_facts("bug-pattern", 10, 0.0)
+        .expect("search bug");
+    assert!(
+        bugs.iter()
+            .any(|f| f.content == "empty outcome list panics cycle")
+    );
+    let lessons = mem
+        .search_facts("lesson-learned", 10, 0.0)
+        .expect("search lesson");
+    assert!(
+        lessons
+            .iter()
+            .any(|f| f.content == "prefer keyword overlap for episodic recall")
+    );
+
+    // The batch is fully consumed.
+    let remaining = mem
+        .list_undistilled_episodes(DISTILL_MIN_EPISODES + 10)
+        .expect("list undistilled");
+    assert!(
+        remaining.is_empty(),
+        "no episode may remain undistilled after a successful pass"
+    );
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// In-process sink applies the SAME gate: ungrounded / empty facts quarantined.
+// ───────────────────────────────────────────────────────────────────────────
+
+/// A stub that emits one grounded good fact, one *ungrounded* fact (citing an
+/// episode not in the batch), and one grounded-but-empty fact. The in-process
+/// `DistillFactSink` must apply the shared reliability gate per fact: only the
+/// good one is stored; the other two are quarantined. This proves gate parity
+/// with the server seam (SEC-T1/T2) on the stub path.
+struct MixedReliabilityRunner;
+
+impl DistillRecipeRunner for MixedReliabilityRunner {
+    fn run(&self, episodes: &[CognitiveEpisode]) -> SimardResult<Vec<DistilledFact>> {
+        Ok(vec![
+            DistilledFact {
+                concept: "bug-pattern".into(),
+                content: "grounded well formed fact".into(),
+                source_episode_id: episodes[0].node_id.clone(),
+            },
+            DistilledFact {
+                concept: "bug-pattern".into(),
+                content: "hallucinated provenance fact".into(),
+                source_episode_id: "epi_not_in_this_batch".into(),
+            },
+            DistilledFact {
+                concept: "lesson-learned".into(),
+                content: "   ".into(), // empty/whitespace → hard quarantine
+                source_episode_id: episodes[1].node_id.clone(),
+            },
+        ])
+    }
+}
+
+#[test]
+fn in_process_sink_quarantines_ungrounded_and_empty_facts() {
+    let n = DISTILL_MIN_EPISODES as usize + 2;
+    let mem = store_with_episodes(n);
+
+    let report = distill_recent_episodes_with_runner(
+        &mem as &dyn CognitiveMemoryOps,
+        &MixedReliabilityRunner,
+    )
+    .expect("pass must succeed even when some facts are quarantined");
+
+    assert_eq!(
+        report.fact_count, 1,
+        "only the grounded, well-formed fact is stored"
+    );
+    assert_eq!(
+        report.quarantined_count, 2,
+        "the ungrounded fact and the empty-content fact must both be quarantined"
+    );
+    // Quarantine must not break the replay guard: every episode is still marked.
+    assert_eq!(report.marked_count as usize, n);
+
+    let facts = mem.search_facts("bug-pattern", 10, 0.0).expect("search");
+    assert!(
+        facts
+            .iter()
+            .all(|f| f.content != "hallucinated provenance fact"),
+        "an ungrounded fact must never leak into semantic memory"
+    );
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Retry-safety: an erroring agentic step leaves the batch fully unmarked.
+// ───────────────────────────────────────────────────────────────────────────
+
+struct ErroringAgenticRunner;
+
+impl DistillRecipeRunner for ErroringAgenticRunner {
+    fn run(&self, _episodes: &[CognitiveEpisode]) -> SimardResult<Vec<DistilledFact>> {
+        Err(SimardError::RpcError(
+            "distill: recipe exited with exit status: 1: stderr= stdout=".into(),
+        ))
+    }
+}
+
+#[test]
+fn erroring_agentic_step_leaves_batch_unmarked_and_stores_nothing() {
+    let n = DISTILL_MIN_EPISODES as usize + 2;
+    let mem = store_with_episodes(n);
+
+    let result = distill_recent_episodes_with_runner(
+        &mem as &dyn CognitiveMemoryOps,
+        &ErroringAgenticRunner,
+    );
+
+    // Either shape is acceptable (fatal Err, or Ok with zero work), but the
+    // store MUST be untouched so the batch is fully retry-eligible next pass.
+    match result {
+        Err(_) => {}
+        Ok(r) => {
+            assert_eq!(r.fact_count, 0, "no facts on agentic-step error");
+            assert_eq!(r.marked_count, 0, "no marks on agentic-step error");
+        }
+    }
+
+    let remaining = mem
+        .list_undistilled_episodes(DISTILL_MIN_EPISODES + 10)
+        .expect("list undistilled");
+    assert_eq!(
+        remaining.len(),
+        n,
+        "retry-safety: no episode may be marked when the agentic step fails"
+    );
+    assert!(
+        mem.search_facts("bug-pattern", 10, 0.0)
+            .expect("search")
+            .is_empty(),
+        "no facts may be stored when the agentic step fails"
+    );
+}
diff --git a/src/memory_consolidation/distillation_tests.rs b/src/memory_consolidation/distillation_tests.rs
index ad154da6..a7653fcb 100644
--- a/src/memory_consolidation/distillation_tests.rs
+++ b/src/memory_consolidation/distillation_tests.rs
@@ -1,55 +1,26 @@
-//! TDD (RED) tests for PR-B: episode distillation.
+//! Pass-behaviour tests for episode distillation (issue #2281, PR-B; gate #2433;
+//! semantic handoff #2679).
 //!
-//! These tests pin the contract documented in
-//! `docs/architecture/episode-distillation.md` for PR-B (issue #2281,
-//! problem 2). They are written **before** the production code change
-//! and are expected to FAIL until PR-B lands.
+//! These pin the distillation PASS contract — under-threshold skip, store +
+//! mark-everything, retry-safety on recipe error, the reliability quarantine
+//! gate, identity dedup, and computed (non-constant) confidence — against a
+//! deterministic in-memory `CognitiveMemoryOps` mock and stub runners.
 //!
-// Test scaffolding intentionally uses a couple of mildly complex
-// shapes (tuple-vec mock + Reverse-by-temporal-index sort) that
-// clippy flags but rewriting would obscure the test intent.
+//! Post-#2679 the distiller commits facts through the in-process
+//! `DistillFactSink` (the default `run_agentic` bridges a run-only stub's facts
+//! into it), applying the SAME shared `crate::fact_reliability` gate the IPC
+//! server uses. The legacy strict-parse / trailing-comma / field-tolerance and
+//! bounded-retry unit tests were RETIRED by #2679 (they asserted a
+//! `parse_facts_document` / retry machinery that no longer exists); their
+//! replacement is `distillation_semantic_handoff_tests` (exit-status-only result
+//! path, gate parity, retry-safety) and `fact_reliability_tests` (the pure
+//! scorer).
 #![allow(clippy::type_complexity)]
 #![allow(clippy::unnecessary_sort_by)]
-//!
-//! ## What PR-B introduces
-//!
-//! * A new module `crate::memory_consolidation::distillation` with:
-//!   * `pub struct DistillReport { input_count, fact_count, marked_count }`
-//!   * `pub fn distill_recent_episodes(memory, repo_root) -> SimardResult<DistillReport>`
-//!   * `pub const DISTILL_BATCH_SIZE: u32` (default 50)
-//!   * `pub const DISTILL_MIN_EPISODES: u32` (default 20)
-//! * Two new methods on `CognitiveMemoryOps` with default no-ops:
-//!   * `fn mark_episode_distilled(&self, node_id: &str) -> SimardResult<()>`
-//!   * `fn list_undistilled_episodes(&self, limit: u32) -> SimardResult<Vec<CognitiveEpisode>>`
-//! * A pluggable recipe runner for the LLM-side distillation step so
-//!   tests can substitute a deterministic stub.
-//!
-//! ## How these compile against pre-PR-B code
-//!
-//! Every reference to the new API is gated behind the symbol path
-//! `crate::memory_consolidation::distillation::*` and the new trait
-//! methods. Because those items do not exist yet, the file will fail
-//! to compile.
-//!
-//! That is the intended TDD red signal — the unresolved-path errors
-//! are concrete, deterministic, and unmistakable. PR-B's first commit
-//! adds the empty types and stubs; this file becomes the contract that
-//! drives the rest of the work.
-//!
-//! Each test below has a header comment listing the precise symbols
-//! that must exist for it to even build, so a future contributor can
-//! satisfy them one at a time.
 
-// `distillation` module does not exist yet (PR-B introduces it).
 use crate::memory_consolidation::distillation::{
-    DISTILL_BATCH_SIZE, DISTILL_FACT_CONFIDENCE, DISTILL_MIN_EPISODES, DISTILL_PARSE_RETRY_MAX,
-    DISTILL_RELIABILITY_THRESHOLD, DistillRecipeRunner, DistilledFact, KNOWN_DISTILL_CONCEPTS,
-    assess_fact_reliability, distill_recent_episodes_with_runner,
-};
-// Fixed fact-yield corpus, shared with `distillation_fact_yield_bench` so the
-// full-pass test below measures the identical input the benchmark records.
-use crate::memory_consolidation::distillation_fact_yield_bench::{
-    BASELINE_PROMOTED, CORPUS_EPISODE_COUNT, CORPUS_RECIPE_JSON, IMPROVED_PROMOTED,
+    DISTILL_BATCH_SIZE, DISTILL_MIN_EPISODES, DistillRecipeRunner, DistilledFact,
+    distill_recent_episodes_with_runner,
 };
 
 use crate::cognitive_memory::CognitiveMemoryOps;
@@ -64,74 +35,50 @@ use std::sync::Mutex;
 use std::sync::atomic::{AtomicU32, Ordering};
 
 // ───────────────────────────────────────────────────────────────────────────
-// Pluggable recipe runner trait
+// Stub runners
 // ───────────────────────────────────────────────────────────────────────────
-//
-// PR-B exposes `DistillRecipeRunner` so tests can inject a deterministic
-// stand-in for `recipe-runner-rs`. Production code will provide a
-// concrete impl that shells out; tests use the stubs in this file.
-//
-// The trait is referenced via the `distill_recent_episodes_with_runner`
-// entry point; the public `distill_recent_episodes(memory, repo_root)`
-// remains the operator-facing call and is covered by integration
-// tests elsewhere.
 
 /// Stub runner that classifies every episode into the supplied facts.
-/// Records the call count so tests can assert the LLM was invoked.
 struct FixedFactsRunner {
     facts: Vec<(String, String, String)>, // (concept, content, source_episode_id)
     call_count: AtomicU32,
 }
 
 impl DistillRecipeRunner for FixedFactsRunner {
-    fn run(
-        &self,
-        episodes: &[CognitiveEpisode],
-    ) -> SimardResult<Vec<crate::memory_consolidation::distillation::DistilledFact>> {
+    fn run(&self, _episodes: &[CognitiveEpisode]) -> SimardResult<Vec<DistilledFact>> {
         self.call_count.fetch_add(1, Ordering::SeqCst);
-        let _ = episodes; // every episode contributes via the fixed-fact set
         Ok(self
             .facts
             .iter()
-            .map(
-                |(c, content, src)| crate::memory_consolidation::distillation::DistilledFact {
-                    concept: c.clone(),
-                    content: content.clone(),
-                    source_episode_id: src.clone(),
-                },
-            )
+            .map(|(c, content, src)| DistilledFact {
+                concept: c.clone(),
+                content: content.clone(),
+                source_episode_id: src.clone(),
+            })
             .collect())
     }
 }
 
-/// Stub runner that always returns a recipe error. Records call count
-/// so the "no markers set" test can verify that the LLM path WAS
-/// invoked but produced no usable output.
+/// Stub runner that always returns a recipe error.
 struct ErroringRunner {
     call_count: AtomicU32,
 }
 
 impl DistillRecipeRunner for ErroringRunner {
-    fn run(
-        &self,
-        _episodes: &[CognitiveEpisode],
-    ) -> SimardResult<Vec<crate::memory_consolidation::distillation::DistilledFact>> {
+    fn run(&self, _episodes: &[CognitiveEpisode]) -> SimardResult<Vec<DistilledFact>> {
         self.call_count.fetch_add(1, Ordering::SeqCst);
         Err(SimardError::RpcError(
-            "stub: recipe runner deliberately failed".to_string(),
+            "distill: recipe exited with exit status: 1: stderr= stdout=".to_string(),
         ))
     }
 }
 
-/// Stub runner that PANICS if invoked. Used by the under-threshold
-/// test to prove the LLM path was bypassed entirely.
+/// Stub runner that PANICS if invoked. Proves the LLM path is bypassed under the
+/// min-episode threshold.
 struct PanickingRunner;
 
 impl DistillRecipeRunner for PanickingRunner {
-    fn run(
-        &self,
-        _episodes: &[CognitiveEpisode],
-    ) -> SimardResult<Vec<crate::memory_consolidation::distillation::DistilledFact>> {
+    fn run(&self, _episodes: &[CognitiveEpisode]) -> SimardResult<Vec<DistilledFact>> {
         panic!("distillation must not invoke the LLM under the min-episode threshold");
     }
 }
@@ -140,26 +87,12 @@ impl DistillRecipeRunner for PanickingRunner {
 // In-memory CognitiveMemoryOps mock with mutable episode store
 // ───────────────────────────────────────────────────────────────────────────
 
-/// A minimal `CognitiveMemoryOps` implementation that lets tests load
-/// an arbitrary set of episodes, observe `store_fact` / `mark_episode_distilled`
-/// calls, and assert post-state.
-///
-/// Wraps state in `Mutex` so the trait's `&self` signature is honoured
-/// while still allowing tests to mutate.
 #[derive(Default)]
 struct EpisodeMock {
     episodes: Mutex<Vec<EpisodeRow>>,
     facts: Mutex<Vec<(String, String, f64, Vec<String>, String)>>, // (concept, content, conf, tags, source)
     mark_calls: Mutex<Vec<String>>,
-    /// Issue #2325: records `store_fact_with_provenance` calls as
-    /// `(concept, source_id, source_episode_ids)` so the distillation
-    /// provenance test can assert the originating episode id was threaded
-    /// through to the provenance write (creating a DERIVES_FROM edge).
     prov_calls: Mutex<Vec<(String, String, Vec<String>)>>,
-    /// Issue #2433: pre-existing facts returned by `search_facts`, keyed by
-    /// concept, so the reliability gate's "don't clobber a stronger prior"
-    /// guard can be exercised. Empty by default → existing tests are
-    /// unaffected (the gate finds no prior to protect).
     seeded_facts: Mutex<Vec<CognitiveFact>>,
 }
 
@@ -181,9 +114,6 @@ impl EpisodeMock {
         }
     }
 
-    /// Like [`with_episodes`](Self::with_episodes) but pre-seeds the facts that
-    /// `search_facts` will return, so the reliability gate's don't-clobber
-    /// guard (issue #2433) can be tested.
     fn with_episodes_and_seeded_facts(rows: Vec<EpisodeRow>, seeded: Vec<CognitiveFact>) -> Self {
         Self {
             episodes: Mutex::new(rows),
@@ -192,9 +122,6 @@ impl EpisodeMock {
         }
     }
 
-    /// Every stored fact as `(concept, content, confidence)` — unlike
-    /// [`facts_stored`](Self::facts_stored) this keeps the confidence so the
-    /// reliability-gate tests can assert the *computed* (non-constant) score.
     fn stored_facts_full(&self) -> Vec<(String, String, f64)> {
         self.facts
             .lock()
@@ -217,8 +144,6 @@ impl EpisodeMock {
         self.mark_calls.lock().unwrap().clone()
     }
 
-    /// `(concept, source_id, source_episode_ids)` for every
-    /// `store_fact_with_provenance` call observed (issue #2325).
     fn provenance_calls(&self) -> Vec<(String, String, Vec<String>)> {
         self.prov_calls.lock().unwrap().clone()
     }
@@ -278,15 +203,11 @@ impl CognitiveMemoryOps for EpisodeMock {
         Ok(format!("sem_{}", self.facts.lock().unwrap().len()))
     }
     fn search_facts(&self, q: &str, _l: u32, min_conf: f64) -> SimardResult<Vec<CognitiveFact>> {
-        // Issue #2433: model the production library faithfully — `search_facts`
-        // matches the concept label and reads the SAME live graph that
-        // `store_fact*` writes to. So return BOTH seeded priors AND facts
-        // already stored earlier in this same pass, filtered by concept == query
-        // and confidence >= min_conf. Reflecting in-pass writes is exactly what
-        // lets the don't-clobber guard's identity check observe an in-batch
-        // sibling (the case the earlier concept-only guard silently regressed
-        // on). Default (no seed, nothing stored yet) → empty, preserving the
-        // pre-#2433 behaviour the other tests rely on.
+        // Model the production library faithfully — `search_facts` matches the
+        // concept label and reads the SAME live graph `store_fact*` writes to, so
+        // return BOTH seeded priors AND facts already stored earlier in this pass,
+        // filtered by concept == query and confidence >= min_conf. This lets the
+        // don't-clobber guard's identity check observe an in-batch sibling.
         let mut out: Vec<CognitiveFact> = self
             .seeded_facts
             .lock()
@@ -327,14 +248,9 @@ impl CognitiveMemoryOps for EpisodeMock {
         Ok(CognitiveStatistics::default())
     }
 
-    // === PR-B trait method overrides ===
-
     fn list_undistilled_episodes(&self, limit: u32) -> SimardResult<Vec<CognitiveEpisode>> {
         let eps = self.episodes.lock().unwrap();
         let mut out: Vec<EpisodeRow> = eps.iter().filter(|e| !e.distilled).cloned().collect();
-        // Newest first by temporal_index descending (UUID-v7 ids are
-        // time-prefixed in production; in tests we just sort by
-        // temporal_index).
         out.sort_by(|a, b| b.temporal_index.cmp(&a.temporal_index));
         out.truncate(limit as usize);
         Ok(out
@@ -358,13 +274,6 @@ impl CognitiveMemoryOps for EpisodeMock {
         Ok(())
     }
 
-    // === Issue #2325 provenance override ===
-    //
-    // Records into BOTH `facts` (so existing `facts_stored()` assertions
-    // keep working once distillation switches to the provenance write) and
-    // `prov_calls` (so the new test can assert the source episode id was
-    // threaded through). Note the LIBRARY argument order: `source_id`
-    // BEFORE `tags`, with `tags`/`metadata` as `Option`s.
     fn store_fact_with_provenance(
         &self,
         concept: &str,
@@ -412,15 +321,26 @@ fn n_episodes(n: usize) -> Vec<EpisodeRow> {
         .collect()
 }
 
+/// Build a pre-existing `CognitiveFact` for seeding the mock's `search_facts`.
+fn seeded_fact(concept: &str, content: &str, confidence: f64) -> CognitiveFact {
+    CognitiveFact {
+        node_id: format!("sem_seed_{concept}"),
+        concept: concept.to_string(),
+        content: content.to_string(),
+        confidence,
+        source_id: "prior".to_string(),
+        tags: vec![concept.to_string()],
+        usage_count: 0,
+        last_accessed_at: None,
+    }
+}
+
 // ───────────────────────────────────────────────────────────────────────────
 // Tests
 // ───────────────────────────────────────────────────────────────────────────
 
-/// Under-threshold gate: when fewer than `DISTILL_MIN_EPISODES`
-/// undistilled episodes are present, the pass MUST be skipped without
-/// invoking the recipe runner or calling `mark_episode_distilled`.
-///
-/// The `PanickingRunner` proves the LLM path is not taken.
+/// Under-threshold gate: fewer than `DISTILL_MIN_EPISODES` undistilled episodes
+/// → the pass is skipped without invoking the runner or marking anything.
 #[test]
 fn distillation_skipped_under_min_threshold() {
     let n = (DISTILL_MIN_EPISODES as usize).saturating_sub(1);
@@ -437,19 +357,12 @@ fn distillation_skipped_under_min_threshold() {
     assert_eq!(report.input_count, 0);
     assert_eq!(report.fact_count, 0);
     assert_eq!(report.marked_count, 0);
-    assert!(
-        mock.marks().is_empty(),
-        "no episodes must be marked distilled when the pass is skipped"
-    );
-    assert!(
-        mock.facts_stored().is_empty(),
-        "no facts must be stored when the pass is skipped"
-    );
+    assert!(mock.marks().is_empty());
+    assert!(mock.facts_stored().is_empty());
 }
 
-/// Above-threshold happy path: 25 episodes (≥ MIN) → recipe returns
-/// 3 facts → 3 `store_fact` calls AND **all 25** episodes marked
-/// distilled (the mark-everything rule prevents replay loops).
+/// Above-threshold happy path: 3 grounded facts → 3 committed AND every input
+/// episode marked distilled (the mark-everything rule prevents replay loops).
 #[test]
 fn distillation_stores_facts_and_marks_originals() {
     let n = DISTILL_MIN_EPISODES as usize + 5;
@@ -485,11 +398,11 @@ fn distillation_stores_facts_and_marks_originals() {
         report.input_count as usize,
         n.min(DISTILL_BATCH_SIZE as usize)
     );
-    assert_eq!(report.fact_count, 3, "3 facts emitted by the recipe stub");
+    assert_eq!(report.fact_count, 3, "3 grounded facts committed");
     assert_eq!(
         report.marked_count as usize,
         n.min(DISTILL_BATCH_SIZE as usize),
-        "every input episode (including those classified 'skip') must be marked distilled"
+        "every input episode must be marked distilled"
     );
     assert_eq!(
         runner.call_count.load(Ordering::SeqCst),
@@ -505,16 +418,11 @@ fn distillation_stores_facts_and_marks_originals() {
     assert!(concepts.contains("lesson-learned"));
 
     let marks_set: std::collections::HashSet<String> = mock.marks().into_iter().collect();
-    assert_eq!(
-        marks_set.len() as u32,
-        report.marked_count,
-        "each marked episode must be marked exactly once"
-    );
+    assert_eq!(marks_set.len() as u32, report.marked_count);
 }
 
-/// Recipe error path: when the recipe runner returns Err, NO facts
-/// are stored AND NO episodes are marked distilled. The batch is
-/// eligible for retry on the next pass.
+/// Recipe error path: when the runner returns Err, NO facts are stored AND NO
+/// episodes are marked distilled — the batch is retry-eligible next pass.
 #[test]
 fn distillation_handles_recipe_error_without_marking() {
     let n = DISTILL_MIN_EPISODES as usize + 5;
@@ -525,10 +433,6 @@ fn distillation_handles_recipe_error_without_marking() {
 
     let report = distill_recent_episodes_with_runner(&mock, &runner);
 
-    // Two acceptable shapes — Err returned, or Ok with zero work
-    // recorded — depending on whether PR-B's author treats recipe
-    // failure as fatal or as "skip this pass". Either shape MUST
-    // leave the store untouched.
     match report {
         Err(_) => {}
         Ok(r) => {
@@ -543,33 +447,28 @@ fn distillation_handles_recipe_error_without_marking() {
     );
     assert!(
         mock.facts_stored().is_empty(),
-        "no facts must be stored when the recipe errors"
+        "no facts stored on recipe error"
     );
     assert!(
         mock.marks().is_empty(),
-        "no markers must be set when the recipe errors — retry-safety invariant"
+        "no markers set on recipe error — retry-safety invariant"
     );
 }
 
-/// Mark-everything rule: even when the recipe classifies every input
-/// as "skip" and returns zero facts, all input episodes MUST be
-/// marked distilled. Otherwise the same low-value episodes would be
-/// resubmitted to the LLM forever.
+/// Mark-everything rule: even when the recipe returns zero facts, all input
+/// episodes MUST be marked distilled so they are not resubmitted forever.
 #[test]
 fn distillation_marks_episodes_classified_as_skip() {
     let n = DISTILL_MIN_EPISODES as usize;
     let mock = EpisodeMock::with_episodes(n_episodes(n));
     let runner = FixedFactsRunner {
-        facts: vec![], // recipe found nothing useful
+        facts: vec![],
         call_count: AtomicU32::new(0),
     };
 
     let report = distill_recent_episodes_with_runner(&mock, &runner).unwrap();
 
-    assert!(
-        !report.was_skipped(),
-        "above-threshold pass must not be skipped"
-    );
+    assert!(!report.was_skipped());
     assert_eq!(report.fact_count, 0);
     assert_eq!(
         report.marked_count as usize, n,
@@ -579,16 +478,12 @@ fn distillation_marks_episodes_classified_as_skip() {
     assert_eq!(mock.marks().len(), n);
 }
 
-/// Independence invariant: distillation MUST NOT touch the
-/// `compressed` flag. That flag is owned by the textual
-/// `consolidate_episodes` pass; the two passes are independent so
-/// their outputs can be attributed in observability.
+/// Independence invariant: distillation MUST NOT touch the `compressed` flag —
+/// that flag is owned by the textual `consolidate_episodes` pass.
 #[test]
 fn distillation_does_not_touch_compressed_flag() {
     let n = DISTILL_MIN_EPISODES as usize + 2;
     let mut rows = n_episodes(n);
-    // Pre-mark two episodes as compressed; distillation must leave
-    // those flags exactly as it found them.
     rows[0].compressed = true;
     rows[3].compressed = true;
     let pre_compressed: Vec<(String, bool)> = rows
@@ -614,15 +509,9 @@ fn distillation_does_not_touch_compressed_flag() {
     );
 }
 
-/// Provenance threading (issue #2325, RED): distillation already knows
-/// each fact's `source_episode_id`. After wiring, it MUST pass that id to
-/// `store_fact_with_provenance` as `source_episode_ids` so a DERIVES_FROM
-/// edge is created — while still encoding the textual `distill:{id}`
-/// `source_id` for back-compat.
-///
-/// Pre-wiring this FAILS: distillation calls the legacy `store_fact`,
-/// which the mock records under `facts` but NOT under `prov_calls`, so
-/// `provenance_calls()` is empty.
+/// Provenance threading (issue #2325): each fact is committed via
+/// `store_fact_with_provenance` with the originating episode id (a DERIVES_FROM
+/// edge) and the textual `distill:{id}` `source_id` for back-compat.
 #[test]
 fn distillation_passes_source_episode_id_as_provenance() {
     let n = DISTILL_MIN_EPISODES as usize + 5;
@@ -644,432 +533,34 @@ fn distillation_passes_source_episode_id_as_provenance() {
     };
 
     let report = distill_recent_episodes_with_runner(&mock, &runner).unwrap();
-    assert_eq!(report.fact_count, 2, "two facts emitted by the stub");
+    assert_eq!(report.fact_count, 2, "two facts committed");
 
     let prov = mock.provenance_calls();
     assert_eq!(
         prov.len(),
         2,
-        "every distilled fact must be stored via store_fact_with_provenance so a \
-         DERIVES_FROM edge is created; got {prov:?}"
+        "every fact stored via store_fact_with_provenance; got {prov:?}"
     );
 
     let by_concept: std::collections::HashMap<&str, &(String, String, Vec<String>)> =
         prov.iter().map(|c| (c.0.as_str(), c)).collect();
 
-    let pr = by_concept
-        .get("pr-pattern")
-        .expect("pr-pattern must be stored with provenance");
+    let pr = by_concept.get("pr-pattern").expect("pr-pattern provenance");
     assert_eq!(
         pr.1, "distill:epi_00003",
-        "textual source_id must retain the distill: prefix for back-compat"
-    );
-    assert_eq!(
-        pr.2,
-        vec!["epi_00003".to_string()],
-        "source_episode_ids must carry the originating episode id"
+        "source_id retains distill: prefix"
     );
+    assert_eq!(pr.2, vec!["epi_00003".to_string()], "episode id threaded");
 
     let bug = by_concept
         .get("bug-pattern")
-        .expect("bug-pattern must be stored with provenance");
+        .expect("bug-pattern provenance");
     assert_eq!(bug.1, "distill:epi_00009");
     assert_eq!(bug.2, vec!["epi_00009".to_string()]);
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Issues #2622/#2619: distill facts-document parse (dedicated file channel)
-// ═══════════════════════════════════════════════════════════════════════════
-//
-// Post-fix the distill agent WRITES its `{ "facts": [...], "procedures": [...] }`
-// envelope to a dedicated facts file and Simard reads THAT file — never the
-// recipe-runner stdout. `parse_facts_document` / `parse_facts` therefore parse
-// the agent's facts document (the file contents). The launcher-banner
-// contamination that motivated the retired stdout-scraping envelope path can no
-// longer reach the parser (see the hermetic `issue_2622_file_channel_tests` in
-// `distillation.rs` for the "banner on stdout, valid file ⇒ success" proof).
-//
-// These tests pin the document parse contract: the facts schema, the concept
-// allow-list, provenance survival, prose/fence tolerance in the file, explicit
-// errors on empty/answerless documents, and bounded/robust error output.
-
-use crate::memory_consolidation::distillation::{parse_facts, parse_facts_document};
-
-/// A representative facts document carrying BOTH facts and procedures.
-const FACTS_AND_PROCEDURES_DOCUMENT: &str = r#"{"facts":[{"concept":"pr-pattern","content":"CI flakes on lbug pin bumps until cache is warmed","source_episode_id":"e7"},{"concept":"lesson-learned","content":"Stale worktrees mask deploy drift","source_episode_id":"e12"}],"procedures":[{"name":"ci-fix:auto","steps":["re-run failed job","warm shared target cache","re-push"],"source_episode_ids":["e7","e9"]}]}"#;
-
-/// A clean facts document must parse into a `DistillOutput`.
-#[test]
-fn document_parses_bare_facts_object() {
-    let out = parse_facts_document(
-        r#"{"facts":[{"concept":"pr-pattern","content":"bare","source_episode_id":"epi_1"}]}"#,
-    )
-    .expect("a clean facts document must parse");
-    assert_eq!(out.facts.len(), 1);
-    assert_eq!(out.facts[0].concept, "pr-pattern");
-    assert_eq!(out.facts[0].source_episode_id, "epi_1");
-    assert!(out.procedures.is_empty());
-}
-
-/// The headline acceptance: a document with facts AND procedures yields both,
-/// with provenance intact — distillation produces semantic + procedural memory.
-#[test]
-fn document_yields_facts_and_procedures() {
-    let out = parse_facts_document(FACTS_AND_PROCEDURES_DOCUMENT)
-        .expect("a facts+procedures document must parse");
-    assert_eq!(out.facts.len(), 2);
-    let concepts: std::collections::HashSet<&str> =
-        out.facts.iter().map(|f| f.concept.as_str()).collect();
-    assert!(concepts.contains("pr-pattern") && concepts.contains("lesson-learned"));
-    let sources: std::collections::HashSet<&str> = out
-        .facts
-        .iter()
-        .map(|f| f.source_episode_id.as_str())
-        .collect();
-    assert!(
-        sources.contains("e7") && sources.contains("e12"),
-        "fact provenance must survive extraction; got {sources:?}"
-    );
-    assert_eq!(out.procedures.len(), 1);
-    let proc = &out.procedures[0];
-    assert_eq!(proc.name, "ci-fix:auto");
-    assert_eq!(proc.steps.len(), 3);
-    assert_eq!(
-        proc.source_episode_ids,
-        vec!["e7".to_string(), "e9".to_string()],
-        "procedure provenance must carry every source episode id"
-    );
-}
-
-/// Concept allow-list: labels outside the closed set are dropped.
-#[test]
-fn document_drops_unknown_concepts() {
-    let out = parse_facts_document(
-        r#"{"facts":[{"concept":"made-up-label","content":"a","source_episode_id":"epi_1"},{"concept":"lesson-learned","content":"b","source_episode_id":"epi_2"}]}"#,
-    )
-    .expect("document must parse");
-    assert_eq!(out.facts.len(), 1, "the made-up label must be filtered out");
-    assert_eq!(out.facts[0].concept, "lesson-learned");
-}
-
-/// The agent may add a little prose or a Markdown fence around its answer in the
-/// file; the facts are still recovered (clean-channel format leniency, NOT the
-/// launcher-banner stdout scraping this fix removed).
-#[test]
-fn document_tolerates_prose_and_fence() {
-    let prose = "Here is the distilled output:\n\
-        {\"facts\":[{\"concept\":\"bug-pattern\",\"content\":\"y\",\"source_episode_id\":\"epi_2\"}]}\n\
-        Done.";
-    let out = parse_facts_document(prose).expect("prose-wrapped document must parse");
-    assert_eq!(out.facts.len(), 1);
-    assert_eq!(out.facts[0].concept, "bug-pattern");
-
-    let fenced = "```json\n\
-        {\"facts\":[{\"concept\":\"pr-pattern\",\"content\":\"z\",\"source_episode_id\":\"epi_3\"}],\"procedures\":[]}\n\
-        ```";
-    let out = parse_facts_document(fenced).expect("fenced document must parse");
-    assert_eq!(out.facts.len(), 1);
-    assert_eq!(out.facts[0].source_episode_id, "epi_3");
-}
-
-/// The facts-only wrapper reads the document too, returning just the facts.
-#[test]
-fn facts_only_wrapper_reads_document() {
-    let facts = parse_facts(FACTS_AND_PROCEDURES_DOCUMENT).expect("facts-only wrapper must parse");
-    assert_eq!(facts.len(), 2);
-}
-
-// ── Failure semantics — explicit Err, never silent degradation ──────────────
-
-/// An empty document (the agent created the file but wrote nothing) is an
-/// explicit `Err` — never a hollow `Ok`.
-#[test]
-fn empty_document_is_err() {
-    assert!(parse_facts_document("").is_err());
-    assert!(parse_facts_document("   \n\t ").is_err());
-}
-
-/// A document with no facts object (e.g. a launcher banner accidentally written
-/// to the file) errors explicitly — the parser never scrapes a banner for a
-/// `{ "facts": [...] }` object.
-#[test]
-fn answerless_document_is_err() {
-    let banner = "\u{2139} NODE_OPTIONS=--max-old-space-size=32768 (saved preference)\n\
-        launching copilot binary=/x version=\"GitHub Copilot CLI 1.0.69-1.\"\n";
-    assert!(parse_facts_document(banner).is_err());
-}
-
-/// A legitimate "nothing worth distilling" answer is a valid SUCCESS (zero
-/// facts), never a parse failure.
-#[test]
-fn empty_facts_envelope_is_success_not_failure() {
-    let out = parse_facts_document(r#"{"facts":[],"procedures":[]}"#)
-        .expect("an empty envelope is a valid success");
-    assert!(out.facts.is_empty() && out.procedures.is_empty());
-}
-
-// ── Robustness — bounded error output, no panic/OOM on hostile input ────────
-
-/// Error output must be bounded and must NOT echo the full document (truncated
-/// excerpt only): a sentinel far past the truncation window must be absent.
-#[test]
-fn document_error_does_not_leak_full_payload() {
-    let sentinel = "SECRET_SENTINEL_AT_END";
-    let raw = format!("{}{sentinel}", "x".repeat(50_000));
-    let err =
-        parse_facts_document(&raw).expect_err("a 50 KiB blob with no facts object must error");
-    let msg = err.to_string();
-    assert!(
-        !msg.contains(sentinel),
-        "error message must not leak content far past the truncation window"
-    );
-    assert!(
-        msg.len() < 600,
-        "error message must stay bounded (truncated excerpt), got {} chars",
-        msg.len()
-    );
-}
-
-/// Pathologically deep brace nesting must terminate with an `Err` — no stack
-/// overflow, no hang.
-#[test]
-fn document_tolerates_deeply_nested_input_without_panic() {
-    let depth = 50_000;
-    let raw = format!("{}{}", "{".repeat(depth), "}".repeat(depth));
-    assert!(
-        parse_facts_document(&raw).is_err(),
-        "deeply nested braces with no facts object must error without panicking"
-    );
-}
-
-/// A large but VALID document (many facts) must extract every fact.
-#[test]
-fn document_handles_large_valid_input() {
-    let facts: Vec<serde_json::Value> = (0..1_000)
-        .map(|i| {
-            serde_json::json!({
-                "concept": "lesson-learned",
-                "content": format!("fact number {i}"),
-                "source_episode_id": format!("epi_{i:05}")
-            })
-        })
-        .collect();
-    let raw =
-        serde_json::to_string(&serde_json::json!({ "facts": facts, "procedures": [] })).unwrap();
-    let out = parse_facts_document(&raw).expect("a large valid document must parse all facts");
-    assert_eq!(
-        out.facts.len(),
-        1_000,
-        "every fact in a large batch must survive"
-    );
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Issue #2433: ISAO-style reliability gate on consolidation
-// ═══════════════════════════════════════════════════════════════════════════
-//
-// Distillation now SELF-ASSESSES each candidate fact's reliability and gates on
-// `Fact.confidence` instead of writing a blind constant (BGML's ISAO, §IV):
-//   * low-reliability candidates are quarantined (not promoted), and
-//   * a weaker new fact never clobbers a stronger existing fact on the concept.
-
-/// Build a pre-existing `CognitiveFact` for seeding the mock's `search_facts`.
-fn seeded_fact(concept: &str, content: &str, confidence: f64) -> CognitiveFact {
-    CognitiveFact {
-        node_id: format!("sem_seed_{concept}"),
-        concept: concept.to_string(),
-        content: content.to_string(),
-        confidence,
-        source_id: "prior".to_string(),
-        tags: vec![concept.to_string()],
-        usage_count: 0,
-        last_accessed_at: None,
-    }
-}
-
-/// A nominal fact — valid in-batch provenance, ≥3 words, known concept —
-/// scores at or above the legacy baseline (0.9) so good facts keep their
-/// downstream behaviour.
-#[test]
-fn reliability_score_nominal_fact_is_above_baseline() {
-    let episodes = vec![CognitiveEpisode {
-        node_id: "epi_00001".to_string(),
-        content: "event 1".to_string(),
-        source_label: "goal-curator".to_string(),
-        temporal_index: 1,
-        compressed: false,
-    }];
-    let fact = DistilledFact {
-        concept: "pr-pattern".to_string(),
-        content: "enable auto-merge before final review".to_string(),
-        source_episode_id: "epi_00001".to_string(),
-    };
-    let score = assess_fact_reliability(&fact, &episodes, std::slice::from_ref(&fact));
-    assert!(
-        (score - 0.9).abs() < 1e-9,
-        "grounded + ≥3 words + known concept must score 0.9; got {score}"
-    );
-    assert!(
-        score >= DISTILL_FACT_CONFIDENCE,
-        "a nominal fact must clear the legacy baseline for continuity"
-    );
-    assert!(score >= DISTILL_RELIABILITY_THRESHOLD);
-}
-
-/// Hallucinated provenance (source episode NOT in the batch) loses the 0.5
-/// grounding weight and drops below the gate even with good content.
-#[test]
-fn reliability_score_ungrounded_fact_is_below_threshold() {
-    let episodes = vec![CognitiveEpisode {
-        node_id: "epi_00001".to_string(),
-        content: "event 1".to_string(),
-        source_label: "goal-curator".to_string(),
-        temporal_index: 1,
-        compressed: false,
-    }];
-    let fact = DistilledFact {
-        concept: "bug-pattern".to_string(),
-        content: "this content looks plausible enough".to_string(),
-        source_episode_id: "epi_99999".to_string(), // not in batch
-    };
-    let score = assess_fact_reliability(&fact, &episodes, std::slice::from_ref(&fact));
-    assert!(
-        score < DISTILL_RELIABILITY_THRESHOLD,
-        "ungrounded provenance must fall below the gate; got {score}"
-    );
-    assert!(
-        (score - 0.4).abs() < 1e-9,
-        "0.3 content + 0.1 concept = 0.4; got {score}"
-    );
-}
-
-/// Corroboration: ≥2 facts agreeing on the same concept this pass adds a 0.1
-/// independent-agreement bonus, taking a nominal fact to a perfect 1.0.
-#[test]
-fn reliability_score_corroboration_bonus_applies() {
-    let episodes = vec![
-        CognitiveEpisode {
-            node_id: "epi_00001".to_string(),
-            content: "event 1".to_string(),
-            source_label: "goal-curator".to_string(),
-            temporal_index: 1,
-            compressed: false,
-        },
-        CognitiveEpisode {
-            node_id: "epi_00002".to_string(),
-            content: "event 2".to_string(),
-            source_label: "goal-curator".to_string(),
-            temporal_index: 2,
-            compressed: false,
-        },
-    ];
-    let batch = vec![
-        DistilledFact {
-            concept: "pr-pattern".to_string(),
-            content: "small PRs merge faster".to_string(),
-            source_episode_id: "epi_00001".to_string(),
-        },
-        DistilledFact {
-            concept: "pr-pattern".to_string(),
-            content: "auto-merge avoids stale reviews".to_string(),
-            source_episode_id: "epi_00002".to_string(),
-        },
-    ];
-    let score = assess_fact_reliability(&batch[0], &episodes, &batch);
-    assert!(
-        (score - 1.0).abs() < 1e-9,
-        "corroborated nominal fact = 1.0; got {score}"
-    );
-    assert!(KNOWN_DISTILL_CONCEPTS.contains(&"pr-pattern"));
-}
-
-/// An off-spec concept loses the concept-validity component.
-#[test]
-fn reliability_score_unknown_concept_loses_weight() {
-    let episodes = vec![CognitiveEpisode {
-        node_id: "epi_00001".to_string(),
-        content: "event 1".to_string(),
-        source_label: "goal-curator".to_string(),
-        temporal_index: 1,
-        compressed: false,
-    }];
-    let fact = DistilledFact {
-        concept: "made-up-concept".to_string(),
-        content: "grounded but off spec concept".to_string(),
-        source_episode_id: "epi_00001".to_string(),
-    };
-    let score = assess_fact_reliability(&fact, &episodes, std::slice::from_ref(&fact));
-    assert!(
-        (score - 0.8).abs() < 1e-9,
-        "0.5 grounded + 0.3 content = 0.8; got {score}"
-    );
-}
-
-/// Hallucinated provenance must not ride on a same-concept sibling's
-/// corroboration to clear the gate: an ungrounded fact stays at 0.4 (content +
-/// concept only) even when corroboration is present, because the corroboration
-/// bonus is awarded only to grounded facts (issue #2433).
-#[test]
-fn reliability_score_ungrounded_corroborated_still_below_threshold() {
-    let episodes = vec![CognitiveEpisode {
-        node_id: "epi_00001".to_string(),
-        content: "event 1".to_string(),
-        source_label: "goal-curator".to_string(),
-        temporal_index: 1,
-        compressed: false,
-    }];
-    // Two same-concept facts → corroboration is present in the batch, but the
-    // fact under test cites an episode NOT in the batch (hallucinated provenance).
-    let batch = vec![
-        DistilledFact {
-            concept: "bug-pattern".to_string(),
-            content: "looks plausible but provenance is fake".to_string(),
-            source_episode_id: "epi_99999".to_string(), // ungrounded
-        },
-        DistilledFact {
-            concept: "bug-pattern".to_string(),
-            content: "a grounded sibling on the same concept".to_string(),
-            source_episode_id: "epi_00001".to_string(),
-        },
-    ];
-    let score = assess_fact_reliability(&batch[0], &episodes, &batch);
-    assert!(
-        (score - 0.4).abs() < 1e-9,
-        "ungrounded + corroborated must stay at 0.3 content + 0.1 concept = 0.4; got {score}"
-    );
-    assert!(
-        score < DISTILL_RELIABILITY_THRESHOLD,
-        "hallucinated provenance must be quarantined regardless of corroboration"
-    );
-}
-
-/// Empty / whitespace-only content is quarantined unconditionally — even with
-/// valid provenance and a known concept it scores 0.0 (issue #2433 hard gate).
-#[test]
-fn reliability_score_empty_content_is_zero() {
-    let episodes = vec![CognitiveEpisode {
-        node_id: "epi_00001".to_string(),
-        content: "event 1".to_string(),
-        source_label: "goal-curator".to_string(),
-        temporal_index: 1,
-        compressed: false,
-    }];
-    let fact = DistilledFact {
-        concept: "pr-pattern".to_string(),
-        content: "   ".to_string(),                 // whitespace only
-        source_episode_id: "epi_00001".to_string(), // grounded, but empty
-    };
-    let score = assess_fact_reliability(&fact, &episodes, std::slice::from_ref(&fact));
-    assert_eq!(
-        score, 0.0,
-        "empty content must score 0.0 regardless of provenance"
-    );
-    assert!(score < DISTILL_RELIABILITY_THRESHOLD);
-}
-
-/// End-to-end gate: a hallucinated-provenance fact is QUARANTINED — not stored
-/// — while the grounded fact in the same batch is promoted. Every episode is
-/// still marked distilled (the quarantine does not break the replay guard).
+/// End-to-end gate: a hallucinated-provenance fact is QUARANTINED while the
+/// grounded fact in the same batch is promoted; every episode is still marked.
 #[test]
 fn distillation_quarantines_low_reliability_fact() {
     let n = DISTILL_MIN_EPISODES as usize + 5;
@@ -1110,16 +601,13 @@ fn distillation_quarantines_low_reliability_fact() {
     );
 }
 
-/// Integrity guard: a weaker new fact must not downgrade a stronger existing
-/// copy of the SAME fact (identity = concept + content). The seeded 0.95 prior
-/// has identical content to the candidate the recipe re-emits at a computed
-/// 0.9, so it is blocked; a distinct fact on another concept is promoted.
+/// Integrity guard: a weaker new fact must not downgrade a stronger existing copy
+/// of the SAME fact (identity = concept + content).
 #[test]
 fn distillation_does_not_clobber_stronger_prior() {
     let n = DISTILL_MIN_EPISODES as usize + 5;
     let mock = EpisodeMock::with_episodes_and_seeded_facts(
         n_episodes(n),
-        // Same concept AND same content as the candidate below, but stronger.
         vec![seeded_fact(
             "pr-pattern",
             "enable auto-merge before final review",
@@ -1150,7 +638,7 @@ fn distillation_does_not_clobber_stronger_prior() {
     );
     assert_eq!(
         report.quarantined_count, 1,
-        "the weaker identical pr-pattern candidate is blocked"
+        "the weaker identical candidate is blocked"
     );
 
     let stored: Vec<(String, String, f64)> = mock.stored_facts_full();
@@ -1162,13 +650,8 @@ fn distillation_does_not_clobber_stronger_prior() {
     assert!(stored.iter().any(|(c, _, _)| c == "bug-pattern"));
 }
 
-/// Regression (issue #2433): two DISTINCT facts that share a concept label must
-/// BOTH be promoted. The recipe emits only three concept labels and every
-/// grounded, well-formed fact scores identically, so an earlier concept-level
-/// don't-clobber guard quarantined every same-concept fact after the first —
-/// silently neutering distillation. The identity-level guard, plus a mock whose
-/// `search_facts` reflects in-pass writes (as production does), proves distinct
-/// same-concept facts accumulate. This test FAILS under the concept-only guard.
+/// Regression (issue #2433): two DISTINCT facts sharing a concept label must BOTH
+/// be promoted — identity dedup, not label dedup.
 #[test]
 fn distillation_promotes_distinct_same_concept_facts() {
     let n = DISTILL_MIN_EPISODES as usize + 5;
@@ -1193,11 +676,11 @@ fn distillation_promotes_distinct_same_concept_facts() {
 
     assert_eq!(
         report.fact_count, 2,
-        "two distinct pr-pattern facts must both be promoted, not deduped by label"
+        "two distinct pr-pattern facts must both be promoted"
     );
     assert_eq!(
         report.quarantined_count, 0,
-        "distinct same-concept facts must not be quarantined as clobbering priors"
+        "distinct same-concept facts must not be quarantined"
     );
 
     let contents: Vec<String> = mock
@@ -1209,8 +692,8 @@ fn distillation_promotes_distinct_same_concept_facts() {
     assert!(contents.contains(&"rebase onto main before requesting review".to_string()));
 }
 
-/// Confidence written to semantic memory is the *computed* reliability score,
-/// not the legacy constant — turning `confidence` into a live signal.
+/// Confidence written to semantic memory is the *computed* reliability score, not
+/// a legacy constant.
 #[test]
 fn distilled_fact_confidence_is_computed_not_constant() {
     let n = DISTILL_MIN_EPISODES as usize + 5;
@@ -1236,409 +719,3 @@ fn distilled_fact_confidence_is_computed_not_constant() {
         "confidence must be the computed score 0.9, not a constant; got {confidence}"
     );
 }
-
-// ───────────────────────────────────────────────────────────────────────────
-// PR-1 (issue #2468): bounded in-cycle distill retry with format reinforcement
-// ───────────────────────────────────────────────────────────────────────────
-//
-// TDD (RED) tests written BEFORE the production change; they FAIL until #2468
-// lands. They pin the contract:
-//
-//   * A *transient* failure class (`ParseFailure`, `CopilotTerminalFailure`) is
-//     retried in-cycle up to `DISTILL_PARSE_RETRY_MAX` times; a recovered batch
-//     stores facts and marks ALL episodes within ONE pass.
-//   * A *structural* class (`SpawnFailure`, `SerializeFailure`) escalates
-//     immediately — NO retry.
-//   * The retry-safety invariant holds across all in-cycle attempts: on final
-//     failure NO facts are stored and NO episodes are marked.
-//
-// Symbol the implementation must add: `pub const DISTILL_PARSE_RETRY_MAX: u32`
-// in `distillation.rs`, plus the retry loop in
-// `distill_recent_episodes_with_runner`.
-
-/// One scripted outcome per `run_all` attempt. Error variants use the exact
-/// stable prefixes `classify_distill_error` anchors on, so each maps to the
-/// intended `DistillFailureClass`.
-enum Attempt {
-    /// Success: emit these `(concept, content, source_episode_id)` facts.
-    Ok(Vec<(&'static str, &'static str, &'static str)>),
-    /// Transient: exited 0 but output unparseable → `ParseFailure`.
-    Parse,
-    /// Transient: recipe process exited non-zero → `CopilotTerminalFailure`.
-    Terminal,
-    /// Structural: runner could not be spawned → `SpawnFailure`.
-    Spawn,
-}
-
-/// Runner that returns a different scripted outcome on each successive call,
-/// recording the call count so the retry bound can be asserted. Once the script
-/// is exhausted it repeats the last outcome.
-struct ScriptedRunner {
-    attempts: Vec<Attempt>,
-    call_count: AtomicU32,
-}
-
-impl ScriptedRunner {
-    fn new(attempts: Vec<Attempt>) -> Self {
-        Self {
-            attempts,
-            call_count: AtomicU32::new(0),
-        }
-    }
-}
-
-impl DistillRecipeRunner for ScriptedRunner {
-    fn run(&self, _episodes: &[CognitiveEpisode]) -> SimardResult<Vec<DistilledFact>> {
-        let idx = self.call_count.fetch_add(1, Ordering::SeqCst) as usize;
-        let attempt = self
-            .attempts
-            .get(idx)
-            .or_else(|| self.attempts.last())
-            .expect("ScriptedRunner needs at least one attempt");
-        match attempt {
-            Attempt::Ok(facts) => Ok(facts
-                .iter()
-                .map(|(c, content, src)| DistilledFact {
-                    concept: (*c).to_string(),
-                    content: (*content).to_string(),
-                    source_episode_id: (*src).to_string(),
-                })
-                .collect()),
-            Attempt::Parse => Err(SimardError::RpcError(
-                "distill: facts document did not contain a parseable { \"facts\": [...] } object: hi"
-                    .to_string(),
-            )),
-            Attempt::Terminal => Err(SimardError::RpcError(
-                "distill: recipe exited with exit status: 1: stderr= stdout=".to_string(),
-            )),
-            Attempt::Spawn => Err(SimardError::RpcError(
-                "distill: recipe-runner-rs spawn failed: no such file".to_string(),
-            )),
-        }
-    }
-}
-
-/// One real, grounded, known-concept fact (passes the ISAO reliability gate) on
-/// the success attempt, tied to a real episode id from `n_episodes`.
-fn recovered_fact() -> Vec<(&'static str, &'static str, &'static str)> {
-    vec![(
-        "pr-pattern",
-        "enable auto-merge before final review",
-        "epi_00001",
-    )]
-}
-
-/// Transient `ParseFailure` on attempt 1, success on attempt 2: the batch
-/// recovers WITHIN ONE PASS — facts stored, every episode marked, runner called
-/// exactly twice.
-#[test]
-fn transient_parse_failure_then_ok_recovers_in_one_pass() {
-    let n = DISTILL_MIN_EPISODES as usize + 5;
-    let mock = EpisodeMock::with_episodes(n_episodes(n));
-    let runner = ScriptedRunner::new(vec![Attempt::Parse, Attempt::Ok(recovered_fact())]);
-
-    let report = distill_recent_episodes_with_runner(&mock, &runner)
-        .expect("transient parse miss must be recovered by an in-cycle retry");
-
-    assert!(report.fact_count >= 1, "facts stored after the retry");
-    assert_eq!(
-        report.marked_count as usize,
-        n.min(DISTILL_BATCH_SIZE as usize),
-        "every input episode marked distilled within the same pass"
-    );
-    assert_eq!(
-        runner.call_count.load(Ordering::SeqCst),
-        2,
-        "exactly one retry after the transient parse miss"
-    );
-    assert!(!mock.facts_stored().is_empty(), "a fact was persisted");
-    assert_eq!(
-        mock.marks().len() as u32,
-        report.marked_count,
-        "marks match the report"
-    );
-}
-
-/// Transient `CopilotTerminalFailure` (non-zero exit) is ALSO retried, then
-/// recovers.
-#[test]
-fn transient_terminal_failure_then_ok_recovers_in_one_pass() {
-    let n = DISTILL_MIN_EPISODES as usize + 2;
-    let mock = EpisodeMock::with_episodes(n_episodes(n));
-    let runner = ScriptedRunner::new(vec![Attempt::Terminal, Attempt::Ok(recovered_fact())]);
-
-    let report = distill_recent_episodes_with_runner(&mock, &runner)
-        .expect("a transient terminal failure must be retried and recovered");
-
-    assert!(report.fact_count >= 1, "facts stored after the retry");
-    assert_eq!(
-        runner.call_count.load(Ordering::SeqCst),
-        2,
-        "the transient terminal failure is retried once"
-    );
-}
-
-/// Both attempts fail transiently: the pass returns `Err`, NO facts are stored,
-/// NO episodes are marked (retry-safety invariant), and the runner is called a
-/// BOUNDED number of times (`DISTILL_PARSE_RETRY_MAX + 1`).
-///
-/// `#[serial]` on the raw-capture env group: this is the one OTHER test that
-/// drives a distill pass to a SURVIVING `ParseFailure`, so it would hit the
-/// Wave 1 capture path and — if it ran concurrently with
-/// `surviving_parse_failure_writes_a_raw_capture_sample_when_enabled` (which
-/// sets the process-global `SIMARD_DISTILL_RAW_CAPTURE*` env) — write a stray
-/// sample into that test's capture dir. Serializing it on the same key keeps the
-/// enabled-capture assertion (`exactly one sample`) deterministic.
-#[test]
-#[serial_test::serial(simard_distill_raw_capture_env, cognitive_memory)]
-fn transient_failure_exhausts_bounded_retries_then_errs_unmarked() {
-    let n = DISTILL_MIN_EPISODES as usize + 3;
-    let mock = EpisodeMock::with_episodes(n_episodes(n));
-    // Always-parse-fail; ScriptedRunner repeats the last outcome past the script.
-    let runner = ScriptedRunner::new(vec![Attempt::Parse]);
-
-    let report = distill_recent_episodes_with_runner(&mock, &runner);
-
-    assert!(report.is_err(), "exhausted retries must surface as Err");
-    assert!(
-        mock.facts_stored().is_empty(),
-        "no facts stored when every attempt fails"
-    );
-    assert!(
-        mock.marks().is_empty(),
-        "retry-safety: no episodes marked when every attempt fails"
-    );
-    assert_eq!(
-        runner.call_count.load(Ordering::SeqCst),
-        DISTILL_PARSE_RETRY_MAX + 1,
-        "retries are bounded: one initial attempt + DISTILL_PARSE_RETRY_MAX retries"
-    );
-}
-
-/// A STRUCTURAL failure (`SpawnFailure`) escalates immediately and is NOT
-/// retried, even though a later attempt would have succeeded.
-#[test]
-fn structural_spawn_failure_is_not_retried() {
-    let n = DISTILL_MIN_EPISODES as usize + 1;
-    let mock = EpisodeMock::with_episodes(n_episodes(n));
-    let runner = ScriptedRunner::new(vec![Attempt::Spawn, Attempt::Ok(recovered_fact())]);
-
-    let report = distill_recent_episodes_with_runner(&mock, &runner);
-
-    assert!(report.is_err(), "a structural failure must escalate");
-    assert_eq!(
-        runner.call_count.load(Ordering::SeqCst),
-        1,
-        "structural classes must NOT be retried"
-    );
-    assert!(
-        mock.marks().is_empty(),
-        "no episodes marked on a structural failure"
-    );
-    assert!(mock.facts_stored().is_empty());
-}
-
-// ───────────────────────────────────────────────────────────────────────────
-// Wave 1 (RED): env-gated raw-capture fires on a SURVIVING parse failure
-// ───────────────────────────────────────────────────────────────────────────
-//
-// Contract (`docs/reference/distill-raw-capture-on-parse-failure.md`): when
-// `SIMARD_DISTILL_RAW_CAPTURE` is truthy and a `ParseFailure` survives the
-// bounded in-cycle retry, the distill failure path in
-// `distill_recent_episodes_with_runner` writes exactly one
-// `distill-parsefail-*.txt` sample under the configured capture dir, carrying a
-// `# failure_class: parse-failure` header.
-//
-// This is a RUNNABLE RED: it references no not-yet-existing symbol (only env +
-// filesystem + the existing runner path), so it COMPILES against today's code
-// and FAILS at runtime because no capture is wired yet. It also pins the
-// requirement that capture is gated by the ENV toggle ONLY — never by
-// `cfg!(test)` — so it is observable under `cargo test`. Wave 1 turns it green.
-
-/// Scoped env override that restores the previous value on drop.
-struct RawCaptureEnvGuard {
-    key: &'static str,
-    prev: Option<std::ffi::OsString>,
-}
-impl RawCaptureEnvGuard {
-    fn set(key: &'static str, value: &str) -> Self {
-        let prev = std::env::var_os(key);
-        // SAFETY: this test is `#[serial]` on the raw-capture env group.
-        unsafe { std::env::set_var(key, value) };
-        Self { key, prev }
-    }
-}
-impl Drop for RawCaptureEnvGuard {
-    fn drop(&mut self) {
-        // SAFETY: this test is `#[serial]` on the raw-capture env group.
-        unsafe {
-            match self.prev.take() {
-                Some(v) => std::env::set_var(self.key, v),
-                None => std::env::remove_var(self.key),
-            }
-        }
-    }
-}
-
-#[test]
-#[serial_test::serial(simard_distill_raw_capture_env, cognitive_memory)]
-fn surviving_parse_failure_writes_a_raw_capture_sample_when_enabled() {
-    let tmp = tempfile::tempdir().unwrap();
-    let capture_dir = tmp.path().join("distill-captures");
-    let _enable = RawCaptureEnvGuard::set("SIMARD_DISTILL_RAW_CAPTURE", "1");
-    let _dir = RawCaptureEnvGuard::set(
-        "SIMARD_DISTILL_RAW_CAPTURE_DIR",
-        capture_dir.to_str().unwrap(),
-    );
-
-    let n = DISTILL_MIN_EPISODES as usize + 3;
-    let mock = EpisodeMock::with_episodes(n_episodes(n));
-    // Every attempt is a ParseFailure ⇒ the retry is exhausted and the pass
-    // escalates with `Err(ParseFailure)` — the exact "surviving parse failure"
-    // the harvester exists to capture.
-    let runner = ScriptedRunner::new(vec![Attempt::Parse]);
-
-    let report = distill_recent_episodes_with_runner(&mock, &runner);
-    assert!(report.is_err(), "a surviving parse failure must return Err");
-
-    let samples: Vec<std::path::PathBuf> = std::fs::read_dir(&capture_dir)
-        .map(|rd| {
-            rd.filter_map(|e| e.ok().map(|e| e.path()))
-                .filter(|p| {
-                    p.file_name()
-                        .and_then(|s| s.to_str())
-                        .is_some_and(|n| n.starts_with("distill-parsefail-") && n.ends_with(".txt"))
-                })
-                .collect()
-        })
-        .unwrap_or_default();
-
-    assert_eq!(
-        samples.len(),
-        1,
-        "an enabled, surviving parse failure must write exactly one capture sample; found {samples:?}"
-    );
-    let body = std::fs::read_to_string(&samples[0]).unwrap();
-    assert!(
-        body.contains("# failure_class: parse-failure"),
-        "captured sample must carry the parse-failure header; body:\n{body}"
-    );
-}
-
-/// Negative control: with capture DISABLED (the default), the same surviving
-/// parse failure writes NO sample. Guards against the diagnostic ever becoming
-/// default-on. Runnable RED until capture exists (the dir is simply never
-/// created); stays green thereafter because the toggle is off.
-#[test]
-#[serial_test::serial(simard_distill_raw_capture_env, cognitive_memory)]
-fn surviving_parse_failure_writes_nothing_when_capture_disabled() {
-    let tmp = tempfile::tempdir().unwrap();
-    let capture_dir = tmp.path().join("distill-captures");
-    // Explicitly OFF, and point the dir override at the tempdir so that IF a
-    // future regression made capture default-on we would still detect the file.
-    let _disable = RawCaptureEnvGuard::set("SIMARD_DISTILL_RAW_CAPTURE", "0");
-    let _dir = RawCaptureEnvGuard::set(
-        "SIMARD_DISTILL_RAW_CAPTURE_DIR",
-        capture_dir.to_str().unwrap(),
-    );
-
-    let n = DISTILL_MIN_EPISODES as usize + 3;
-    let mock = EpisodeMock::with_episodes(n_episodes(n));
-    let runner = ScriptedRunner::new(vec![Attempt::Parse]);
-
-    let report = distill_recent_episodes_with_runner(&mock, &runner);
-    assert!(report.is_err(), "a surviving parse failure must return Err");
-
-    let created_any = std::fs::read_dir(&capture_dir)
-        .map(|mut rd| rd.next().is_some())
-        .unwrap_or(false);
-    assert!(
-        !created_any,
-        "capture is default-off: no sample may be written when the toggle is falsy"
-    );
-}
-
-// ───────────────────────────────────────────────────────────────────────────
-// Full-pass companion to the deterministic fact-yield benchmark
-// ───────────────────────────────────────────────────────────────────────────
-
-/// Runner that parses a fixed raw facts document through the REAL production
-/// parse path (`parse_facts_document`), so the concept canonicalization in
-/// `RecipeEnvelope::into_facts` is exercised end-to-end via
-/// `distill_recent_episodes_with_runner` (parse → gate → dedup guard → store)
-/// rather than bypassed by a facts-returning stub.
-struct RawEnvelopeRunner {
-    raw: &'static str,
-    call_count: AtomicU32,
-}
-
-impl DistillRecipeRunner for RawEnvelopeRunner {
-    fn run(&self, _episodes: &[CognitiveEpisode]) -> SimardResult<Vec<DistilledFact>> {
-        self.call_count.fetch_add(1, Ordering::SeqCst);
-        parse_facts_document(self.raw).map(|o| o.facts)
-    }
-}
-
-/// Full-pass companion to `distillation_fact_yield_bench`. Routes the SAME fixed
-/// corpus through the real `distill_recent_episodes_with_runner` — parse +
-/// concept canonicalization + reliability gate + the identity dedup guard +
-/// storage — against a FRESH (empty) memory, and confirms all `IMPROVED_PROMOTED`
-/// canonical / surface-variant grounded facts are actually stored while the
-/// ungrounded and empty candidates are quarantined. This upgrades the
-/// benchmark's "dedup-neutral corpus ⇒ parse+gate survivors == full-pass
-/// promoted" claim from *asserted* to *exercised*, closing the gap between the
-/// DB-free benchmark and a real production pass.
-#[test]
-fn full_pass_promotes_canonicalized_surface_variants_through_dedup() {
-    let rows: Vec<EpisodeRow> = (0..CORPUS_EPISODE_COUNT)
-        .map(|i| EpisodeRow {
-            node_id: format!("ep-{i:03}"),
-            content: format!("episode {i} body"),
-            source_label: "distill-bench".to_string(),
-            temporal_index: i as i64,
-            compressed: false,
-            distilled: false,
-        })
-        .collect();
-    let mock = EpisodeMock::with_episodes(rows);
-    let runner = RawEnvelopeRunner {
-        raw: CORPUS_RECIPE_JSON,
-        call_count: AtomicU32::new(0),
-    };
-
-    let report = distill_recent_episodes_with_runner(&mock, &runner).unwrap();
-
-    // The runner (and thus the LLM-side parse) ran exactly once — no transient
-    // retry, since the fixed corpus parses cleanly.
-    assert_eq!(runner.call_count.load(Ordering::SeqCst), 1);
-
-    // All eight canonical/surface-variant grounded facts are promoted through the
-    // FULL pipeline (dedup guard included), matching the benchmark's parse+gate
-    // survivor count. The two precision-guard candidates (ungrounded ep-999 and
-    // empty content) are quarantined by the reliability gate; the three off-spec
-    // concepts are dropped at the concept filter (not counted as quarantined).
-    assert_eq!(
-        report.fact_count, IMPROVED_PROMOTED as u32,
-        "full pass must promote all recovered surface-variant facts"
-    );
-    assert_eq!(
-        report.quarantined_count, 2,
-        "ungrounded + empty candidates must be quarantined by the reliability gate"
-    );
-    assert!(
-        report.fact_count > BASELINE_PROMOTED as u32,
-        "full-pass yield must exceed the exact-match baseline"
-    );
-
-    // Every stored fact carries a canonical lower-hyphen concept label, proving
-    // canonicalization normalized the surface variants before storage.
-    for (concept, _content) in mock.facts_stored() {
-        assert!(
-            matches!(
-                concept.as_str(),
-                "pr-pattern" | "bug-pattern" | "lesson-learned"
-            ),
-            "stored concept was not canonicalized: {concept:?}"
-        );
-    }
-}
diff --git a/src/memory_consolidation/mod.rs b/src/memory_consolidation/mod.rs
index ac1f3477..883f1309 100644
--- a/src/memory_consolidation/mod.rs
+++ b/src/memory_consolidation/mod.rs
@@ -981,13 +981,22 @@ pub mod scheduler;
 #[cfg(test)]
 mod distillation_tests;
 
-// Perpetual-cognition sub-goal: raise distillation fact-yield. A deterministic,
-// DB-free benchmark that records a baseline facts-per-consolidation-input number
-// over a fixed sample corpus and proves the concept-canonicalization change
-// raises yield without lowering precision. See
-// `docs/architecture/episode-distillation.md` §"Fact-yield benchmark".
+// TDD (RED) for issue #2679: the semantic agent→agent handoff replacing the
+// brittle JSON extraction/deserialization gate. Pins that the result path is an
+// exit-status check (no stdout parse), that the agentic step commits facts via
+// the shared gated write boundary, and that noisy/trailing-comma output can no
+// longer fail the pipeline. Symbols (`interpret_recipe_exit`, `run_agentic`)
+// land in the implementation step; until then this module is the red signal.
 #[cfg(test)]
-mod distillation_fact_yield_bench;
+mod distillation_semantic_handoff_tests;
+
+// Perpetual-cognition sub-goal: raise distillation fact-yield. RETIRED by issue
+// #2679: the benchmark measured the yield of the `parse_facts_document` +
+// `assess_fact_reliability` parse/filter path, which no longer exists — the
+// distiller now writes facts DIRECTLY through the memory write boundary, so there
+// is nothing to parse and the corroboration-bearing batch scorer was replaced by
+// the shared per-fact `crate::fact_reliability` scorer. See
+// `docs/architecture/distillation-semantic-handoff.md`.
 
 // PR-C (issue #2281, problem 4): episodic recall tests for
 // `preparation_memory_operations`. Pins the tokenizer rules,
diff --git a/src/memory_ipc/client.rs b/src/memory_ipc/client.rs
index 9d08ac0f..fd2adf4f 100644
--- a/src/memory_ipc/client.rs
+++ b/src/memory_ipc/client.rs
@@ -12,7 +12,7 @@ use crate::memory_cognitive::{
     CognitiveWorkingSlot,
 };
 
-use super::{MemoryRequest, MemoryResponse, ipc_err, read_frame, write_frame};
+use super::{FactWriteOutcome, MemoryRequest, MemoryResponse, ipc_err, read_frame, write_frame};
 
 // ============================================================================
 // Client
@@ -88,6 +88,74 @@ impl RemoteCognitiveMemory {
             },
         }
     }
+
+    /// Commit ONE distilled fact through the daemon's authoritative
+    /// write-boundary gate (issue #2679). The server grounds, scores,
+    /// quarantines, dedups, and persists the fact; the returned
+    /// [`FactWriteOutcome`] reports the server's disposition and the confidence
+    /// it computed (never the `confidence` hint passed here). This is the wire
+    /// the distiller agentic step uses via `simard memory remember` — there is
+    /// no return document for anyone to deserialize.
+    #[allow(clippy::too_many_arguments)]
+    pub fn remember_fact_gated(
+        &self,
+        concept: &str,
+        content: &str,
+        confidence: f64,
+        tags: &[String],
+        source_id: &str,
+        source_episode_ids: &[String],
+        pass_id: &str,
+    ) -> SimardResult<FactWriteOutcome> {
+        match self.call(MemoryRequest::StoreFactGated {
+            concept: concept.into(),
+            content: content.into(),
+            confidence,
+            tags: tags.to_vec(),
+            source_id: source_id.into(),
+            source_episode_ids: source_episode_ids.to_vec(),
+            pass_id: pass_id.into(),
+        })? {
+            MemoryResponse::FactWrite(o) => Ok(o),
+            other => Err(Self::unexpected("remember_fact_gated", other)),
+        }
+    }
+
+    /// Commit ONE distilled procedure with its source-episode provenance (issue
+    /// #2679), returning the new node id. The companion of
+    /// [`remember_fact_gated`](Self::remember_fact_gated) for the distiller's
+    /// procedure output.
+    pub fn remember_procedure_provenance(
+        &self,
+        name: &str,
+        steps: &[String],
+        prerequisites: &[String],
+        source_episode_ids: &[String],
+        pass_id: &str,
+    ) -> SimardResult<String> {
+        match self.call(MemoryRequest::StoreProcedureProvenance {
+            name: name.into(),
+            steps: steps.to_vec(),
+            prerequisites: prerequisites.to_vec(),
+            source_episode_ids: source_episode_ids.to_vec(),
+            pass_id: pass_id.into(),
+        })? {
+            MemoryResponse::Id(id) => Ok(id),
+            other => Err(Self::unexpected("remember_procedure_provenance", other)),
+        }
+    }
+
+    /// Drain and return the count of facts the write-boundary gate ACCEPTED for
+    /// `pass_id` (issue #2679). Used by the distiller subprocess to report a
+    /// pass's committed-fact count when there is no returned document to count.
+    pub fn drain_pass_ledger(&self, pass_id: &str) -> SimardResult<usize> {
+        match self.call(MemoryRequest::DrainPassLedger {
+            pass_id: pass_id.into(),
+        })? {
+            MemoryResponse::Count(n) => Ok(n),
+            other => Err(Self::unexpected("drain_pass_ledger", other)),
+        }
+    }
 }
 
 impl CognitiveMemoryOps for RemoteCognitiveMemory {
diff --git a/src/memory_ipc/mod.rs b/src/memory_ipc/mod.rs
index e09cc0e2..b5523026 100644
--- a/src/memory_ipc/mod.rs
+++ b/src/memory_ipc/mod.rs
@@ -25,6 +25,12 @@ mod tests_client_isolation;
 mod tests_default_state_root_1967;
 #[cfg(test)]
 mod tests_launcher;
+// TDD (RED) for issue #2679: additive gated-write protocol (StoreFactGated /
+// StoreProcedureProvenance / FactWriteOutcome), the MAX_FRAME cap, and the
+// RemoteCognitiveMemory remember_* client wrappers. Symbols are added in the
+// implementation step; until then the unresolved paths are the red signal.
+#[cfg(test)]
+mod tests_gated_write_2679;
 #[cfg(test)]
 mod tests_shared_store_2320;
 #[cfg(test)]
@@ -97,6 +103,22 @@ pub fn socket_path_for(state_root: &Path) -> PathBuf {
 /// daemon at a known path.
 pub const MEMORY_SOCKET_ENV: &str = "SIMARD_MEMORY_SOCKET";
 
+/// Environment variable that carries the distillation pass id to every
+/// `simard memory remember` subprocess the distiller agent spawns (issue
+/// #2679).
+///
+/// The distill runner exports this so a fact write tags the daemon's per-pass
+/// write ledger even though the agent invokes the CLI with only the scalar
+/// content flags (`--concept` / `--content` / `--source-episode-id`) and NO
+/// explicit `--pass-id`. The `remember` CLI reads it as a fallback when
+/// `--pass-id` is absent; that fallback is what lets `drain_pass_ledger`
+/// report a real accepted-fact count on the production
+/// distill path. Without it the pass id resolved empty, the server's ledger
+/// no-op'd the write, and every pass reported `fact_count = 0` /
+/// `reduction_pct = 100%` while facts were in fact stored (the silent
+/// metrics-degradation regression fixed in the #2679 follow-up).
+pub const DISTILL_PASS_ID_ENV: &str = "SIMARD_DISTILL_PASS_ID";
+
 /// Environment variable that opts a test out of the hermetic-state-root
 /// guard. Read by the cfg(test)-only assertion sites
 /// (`save_goal_board` / `save_goal_board_with_removals`, the cognitive-memory
@@ -164,6 +186,25 @@ pub enum MemoryRequest {
         tags: Vec<String>,
         source_id: String,
     },
+    /// Gated per-fact write (issue #2679). Carries one distilled fact from the
+    /// distiller agentic step (via `simard memory remember`) to the daemon's
+    /// authoritative write-boundary gate. The server — NOT the client — grounds
+    /// the fact against the store, scores it with the shared
+    /// [`crate::fact_reliability`] scorer, quarantines anything below threshold,
+    /// dedups against an equal-or-stronger prior, and persists survivors with the
+    /// *server-computed* confidence and provenance edges. The client-supplied
+    /// `confidence` is only a hint the server ignores; `source_episode_ids` is
+    /// the provenance the server verifies. There is no return document to parse —
+    /// the disposition flows back as [`MemoryResponse::FactWrite`].
+    StoreFactGated {
+        concept: String,
+        content: String,
+        confidence: f64,
+        tags: Vec<String>,
+        source_id: String,
+        source_episode_ids: Vec<String>,
+        pass_id: String,
+    },
     SearchFacts {
         query: String,
         limit: u32,
@@ -174,6 +215,17 @@ pub enum MemoryRequest {
         steps: Vec<String>,
         prerequisites: Vec<String>,
     },
+    /// Procedure write carrying its source-episode provenance (issue #2679), so
+    /// the daemon draws a `PROCEDURE_DERIVES_FROM` edge to each source episode.
+    /// The companion of [`StoreFactGated`](MemoryRequest::StoreFactGated) for the
+    /// distiller's procedure output. Returns [`MemoryResponse::Id`].
+    StoreProcedureProvenance {
+        name: String,
+        steps: Vec<String>,
+        prerequisites: Vec<String>,
+        source_episode_ids: Vec<String>,
+        pass_id: String,
+    },
     RecallProcedure {
         query: String,
         limit: u32,
@@ -196,6 +248,15 @@ pub enum MemoryRequest {
         keywords: Vec<String>,
         limit: u32,
     },
+    /// Drain and return the count of facts the write-boundary gate ACCEPTED for
+    /// a given distillation `pass_id` (issue #2679). The distiller subprocess
+    /// tags each `StoreFactGated` write with its `pass_id`; after the recipe run
+    /// it drains the ledger to report how many facts the gate accepted — the only
+    /// way to count facts on a path with no returned document. Returns
+    /// [`MemoryResponse::Count`].
+    DrainPassLedger {
+        pass_id: String,
+    },
     GetStatistics,
 }
 
@@ -215,10 +276,31 @@ pub enum MemoryResponse {
     /// [`MemoryRequest::SearchEpisodesByKeywords`].
     Episodes(Vec<CognitiveEpisode>),
     Statistics(CognitiveStatistics),
+    /// Server-side disposition of a [`MemoryRequest::StoreFactGated`] write
+    /// (issue #2679): whether the fact was stored or quarantined and the
+    /// confidence the server *computed* (never the client's hint). Reported so a
+    /// caller — and the `simard memory remember` CLI — can surface the result
+    /// WITHOUT any document to deserialize.
+    FactWrite(FactWriteOutcome),
     Ack,
     Error(String),
 }
 
+/// The server's decision for one gated fact write (issue #2679).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FactWriteOutcome {
+    /// The fact cleared the gate and was persisted.
+    pub stored: bool,
+    /// The fact was blocked by the gate (ungrounded, empty content, below
+    /// threshold, or an equal-or-stronger prior already exists) and NOT stored.
+    pub quarantined: bool,
+    /// The confidence the server computed from the shared reliability scorer
+    /// (NOT the client-supplied hint).
+    pub confidence: f64,
+    /// The `node_id` of the persisted fact, present only when `stored`.
+    pub node_id: Option<String>,
+}
+
 pub(crate) fn ipc_err(ctx: &str, e: impl std::fmt::Display) -> SimardError {
     SimardError::RpcTransportError {
         bridge: "memory-ipc".to_string(),
@@ -226,6 +308,15 @@ pub(crate) fn ipc_err(ctx: &str, e: impl std::fmt::Display) -> SimardError {
     }
 }
 
+/// Maximum accepted framed-message body size (issue #2679 socket hardening).
+///
+/// A hostile or corrupt client can send a 4-byte length prefix claiming a
+/// multi-gigabyte body; the frame reader rejects any length exceeding this cap
+/// BEFORE allocating or reading the body, so a bad prefix can never trigger a
+/// giant allocation. 8 MiB is far larger than any legitimate per-fact write (a
+/// single fact is a few hundred bytes) yet small enough to bound abuse.
+pub(crate) const MAX_FRAME: usize = 8 * 1024 * 1024;
+
 pub(crate) fn write_frame<W: Write>(w: &mut W, payload: &[u8]) -> SimardResult<()> {
     let len = u32::try_from(payload.len()).map_err(|_| SimardError::RpcTransportError {
         bridge: "memory-ipc".into(),
@@ -242,6 +333,15 @@ pub(crate) fn read_frame<R: Read>(r: &mut R) -> SimardResult<Vec<u8>> {
     r.read_exact(&mut len_buf)
         .map_err(|e| ipc_err("read-len", e))?;
     let len = u32::from_be_bytes(len_buf) as usize;
+    // Reject an oversized length BEFORE allocating or reading the body, so a
+    // corrupt/hostile prefix cannot force a huge `vec![0u8; len]` allocation
+    // (issue #2679 socket hardening).
+    if len > MAX_FRAME {
+        return Err(SimardError::RpcTransportError {
+            bridge: "memory-ipc".into(),
+            reason: format!("frame length {len} exceeds MAX_FRAME {MAX_FRAME}"),
+        });
+    }
     let mut buf = vec![0u8; len];
     r.read_exact(&mut buf)
         .map_err(|e| ipc_err("read-body", e))?;
@@ -259,7 +359,6 @@ pub use launcher::{
     register_in_process_writer,
 };
 pub use server::{ServerHandle, spawn_server};
-
 // ============================================================================
 // Shared-memory adapter: Arc → Box<dyn CognitiveMemoryOps>
 // ============================================================================
@@ -367,6 +466,12 @@ impl CognitiveMemoryOps for SharedMemory {
     fn mark_episode_distilled(&self, node_id: &str) -> SimardResult<()> {
         self.0.mark_episode_distilled(node_id)
     }
+    fn episode_exists(&self, node_id: &str) -> SimardResult<bool> {
+        self.0.episode_exists(node_id)
+    }
+    fn any_episode_exists(&self, node_ids: &[String]) -> SimardResult<bool> {
+        self.0.any_episode_exists(node_ids)
+    }
     fn list_undistilled_episodes(&self, limit: u32) -> SimardResult<Vec<CognitiveEpisode>> {
         self.0.list_undistilled_episodes(limit)
     }
diff --git a/src/memory_ipc/server.rs b/src/memory_ipc/server.rs
index 3fd653ac..3f37c977 100644
--- a/src/memory_ipc/server.rs
+++ b/src/memory_ipc/server.rs
@@ -9,6 +9,12 @@ use crate::cognitive_memory::CognitiveMemoryOps;
 use crate::error::{SimardError, SimardResult};
 
 use super::{MemoryRequest, MemoryResponse, ipc_err, read_frame, write_frame};
+// TDD (RED) for issue #2679: the authoritative server-side write-boundary gate
+// (StoreFactGated dispatch arm). The gate + response variants are added in the
+// implementation step; until then the unresolved symbols in this module are the
+// red signal. `#[cfg(test)]` so production builds never compile it.
+#[cfg(test)]
+mod server_gate_tests;
 
 // ============================================================================
 // Server
@@ -26,6 +32,12 @@ pub fn spawn_server(
 ) -> SimardResult<ServerHandle> {
     if let Some(parent) = socket_path.parent() {
         let _ = std::fs::create_dir_all(parent);
+        // Restrict the socket's parent directory to the owner (0700) so no other
+        // local user can traverse to the memory socket (issue #2679 hardening).
+        // Best-effort: a permissions failure must not prevent the daemon from
+        // serving memory.
+        use std::os::unix::fs::PermissionsExt;
+        let _ = std::fs::set_permissions(parent, std::fs::Permissions::from_mode(0o700));
     }
     // Always unlink the socket file before binding.
     //
@@ -42,6 +54,13 @@ pub fn spawn_server(
         bridge: "memory-ipc".into(),
         reason: format!("bind {}: {e}", socket_path.display()),
     })?;
+    // Restrict the socket file to owner read/write (0600) so only this user's
+    // processes (daemon, meeting, engineer, distill) can send memory writes
+    // (issue #2679 hardening). Best-effort.
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let _ = std::fs::set_permissions(&socket_path, std::fs::Permissions::from_mode(0o600));
+    }
 
     let socket_clone = socket_path.clone();
     let mem = Arc::clone(&memory);
@@ -161,6 +180,12 @@ fn dispatch(memory: &dyn CognitiveMemoryOps, req: MemoryRequest) -> MemoryRespon
                 Err(e) => MemoryResponse::Error(e.to_string()),
             }
         }
+        // The ungated, trusted direct-write path. This is NOT the distillation
+        // boundary: it persists the caller's fact and confidence verbatim, so it
+        // is reserved for in-process / same-user callers that are already trusted
+        // (manual writes, imports, tests). Distiller agent writes MUST use
+        // `StoreFactGated` below, which re-grounds, re-scores, dedups, and
+        // quarantines server-side and never trusts the client's confidence.
         MemoryRequest::StoreFact {
             concept,
             content,
@@ -171,6 +196,25 @@ fn dispatch(memory: &dyn CognitiveMemoryOps, req: MemoryRequest) -> MemoryRespon
             Ok(id) => MemoryResponse::Id(id),
             Err(e) => MemoryResponse::Error(e.to_string()),
         },
+        MemoryRequest::StoreFactGated {
+            concept,
+            content,
+            // The client's confidence is a hint the server must NOT trust; the
+            // gate re-derives it from the shared reliability scorer below.
+            confidence: _client_hint,
+            tags,
+            source_id,
+            source_episode_ids,
+            pass_id,
+        } => gated_fact_write(
+            memory,
+            &concept,
+            &content,
+            &tags,
+            &source_id,
+            &source_episode_ids,
+            &pass_id,
+        ),
         MemoryRequest::SearchFacts {
             query,
             limit,
@@ -187,6 +231,43 @@ fn dispatch(memory: &dyn CognitiveMemoryOps, req: MemoryRequest) -> MemoryRespon
             Ok(id) => MemoryResponse::Id(id),
             Err(e) => MemoryResponse::Error(e.to_string()),
         },
+        MemoryRequest::StoreProcedureProvenance {
+            name,
+            steps,
+            prerequisites,
+            source_episode_ids,
+            pass_id: _,
+        } => {
+            // Grounding symmetry with the fact write-boundary gate (issue #2679):
+            // a procedure that CITES source episodes must have at least one that
+            // resolves to a real node here, else its provenance is fabricated and
+            // the `PROCEDURE_DERIVES_FROM` edges would dangle. Procedures carry no
+            // reliability score (unlike facts they are not confidence-graded), so
+            // this is a grounding-only guard — cited-but-unresolvable provenance is
+            // rejected fail-closed; a procedure that cites nothing is stored
+            // unchanged (there is no fabricated provenance to reject).
+            if !source_episode_ids.is_empty()
+                && !memory
+                    .any_episode_exists(&source_episode_ids)
+                    .unwrap_or(false)
+            {
+                MemoryResponse::Error(
+                    "procedure rejected: none of its cited source episodes resolve \
+                     (ungrounded provenance)"
+                        .to_string(),
+                )
+            } else {
+                match memory.store_procedure_with_provenance(
+                    &name,
+                    &steps,
+                    &prerequisites,
+                    &source_episode_ids,
+                ) {
+                    Ok(id) => MemoryResponse::Id(id),
+                    Err(e) => MemoryResponse::Error(e.to_string()),
+                }
+            }
+        }
         MemoryRequest::RecallProcedure { query, limit } => {
             match memory.recall_procedure(&query, limit) {
                 Ok(v) => MemoryResponse::Procedures(v),
@@ -223,9 +304,154 @@ fn dispatch(memory: &dyn CognitiveMemoryOps, req: MemoryRequest) -> MemoryRespon
                 Err(e) => MemoryResponse::Error(e.to_string()),
             }
         }
+        MemoryRequest::DrainPassLedger { pass_id } => {
+            MemoryResponse::Count(drain_pass_ledger(&pass_id))
+        }
         MemoryRequest::GetStatistics => match memory.get_statistics() {
             Ok(s) => MemoryResponse::Statistics(s),
             Err(e) => MemoryResponse::Error(e.to_string()),
         },
     }
 }
+
+// ───────────────────────────────────────────────────────────────────────────
+// Distillation write ledger (issue #2679)
+// ───────────────────────────────────────────────────────────────────────────
+//
+// A per-`pass_id` count of facts the write-boundary gate ACCEPTED, so the
+// distiller subprocess — which gets NO returned document (facts are agent
+// writes) — can report how many facts a pass committed. Best-effort telemetry
+// state: bounded by drain-on-read and never surfaced as an error.
+
+use std::collections::HashMap;
+use std::sync::{Mutex, OnceLock};
+
+fn pass_ledger() -> &'static Mutex<HashMap<String, u32>> {
+    static LEDGER: OnceLock<Mutex<HashMap<String, u32>>> = OnceLock::new();
+    LEDGER.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+/// Record one gate-accepted fact for `pass_id`. No-op for an empty `pass_id`
+/// (a caller that does not participate in the ledger).
+fn ledger_record_stored(pass_id: &str) {
+    if pass_id.is_empty() {
+        return;
+    }
+    if let Ok(mut guard) = pass_ledger().lock() {
+        // Avoid allocating a fresh key String on every accepted fact: only the
+        // first fact of a pass needs to insert; later facts bump the count in
+        // place.
+        if let Some(count) = guard.get_mut(pass_id) {
+            *count += 1;
+        } else {
+            guard.insert(pass_id.to_string(), 1);
+        }
+    }
+}
+
+/// Remove and return the accepted-fact count for `pass_id` (0 if unknown).
+fn drain_pass_ledger(pass_id: &str) -> usize {
+    pass_ledger()
+        .lock()
+        .ok()
+        .and_then(|mut g| g.remove(pass_id))
+        .unwrap_or(0) as usize
+}
+
+/// The authoritative server-side distillation write-boundary gate (issue #2679).
+///
+/// Applied per fact when the distiller agentic step commits a fact through the
+/// daemon socket. The server — NOT the client, NOT Simard's distillation module —
+/// decides every fact's disposition here, in order:
+///
+///   0. **Validate** the opaque input fields (non-empty, within length caps).
+///   1. **Ground** the fact by confirming at least one `source_episode_id`
+///      resolves to a real episode node in the store (store-existence check).
+///   2. **Score → quarantine → dedup → persist** via the single shared
+///      [`crate::fact_reliability::commit_gated_fact`], so this server seam and
+///      the in-process `DistillFactSink` reach an identical store/quarantine
+///      decision. The client's `confidence` hint is NEVER consulted; the gate
+///      re-derives confidence from the resolved `grounded` flag, quarantines
+///      anything below `RELIABILITY_THRESHOLD` or duplicating an equal-or-stronger
+///      prior, and persists survivors via `store_fact_with_provenance`.
+///
+/// The disposition flows back as [`MemoryResponse::FactWrite`] — there is no
+/// document for Simard to deserialize anywhere in the path.
+fn gated_fact_write(
+    memory: &dyn CognitiveMemoryOps,
+    concept: &str,
+    content: &str,
+    tags: &[String],
+    source_id: &str,
+    source_episode_ids: &[String],
+    pass_id: &str,
+) -> MemoryResponse {
+    use crate::fact_reliability::{FactGateDecision, commit_gated_fact};
+
+    // (0) Input validation at the boundary (issue #2679 hardening). Every field
+    // is opaque data; a required field that is empty, or a field that exceeds its
+    // length cap, is rejected (quarantined — nothing stored) rather than
+    // truncated silently. `MAX_FRAME` already bounds the whole request; these
+    // per-field caps bound each value within it.
+    const MAX_CONCEPT_LEN: usize = 256;
+    const MAX_CONTENT_LEN: usize = 64 * 1024;
+    if concept.trim().is_empty()
+        || content.trim().is_empty()
+        || concept.len() > MAX_CONCEPT_LEN
+        || content.len() > MAX_CONTENT_LEN
+    {
+        return MemoryResponse::FactWrite(super::FactWriteOutcome {
+            stored: false,
+            quarantined: true,
+            confidence: 0.0,
+            node_id: None,
+        });
+    }
+
+    // (1) Grounding — the fact is grounded iff at least one cited episode id
+    // resolves to a real node in this store. The batch `any_episode_exists`
+    // materializes the episode set once for all cited ids (rather than once per
+    // id). A lookup error is treated as "does not resolve" (fail-closed), so a
+    // backend hiccup can never accidentally promote an ungrounded fact.
+    let grounded = memory
+        .any_episode_exists(source_episode_ids)
+        .unwrap_or(false);
+
+    // (2–5) Score → threshold → dedup → persist through the single shared gate,
+    // so this server seam and the in-process `DistillFactSink` decide every
+    // fact's disposition identically. The client's `confidence` hint is never
+    // consulted; the gate re-derives it.
+    match commit_gated_fact(
+        memory,
+        concept,
+        content,
+        grounded,
+        source_id,
+        tags,
+        source_episode_ids,
+    ) {
+        Ok(FactGateDecision::Stored {
+            confidence,
+            node_id,
+        }) => {
+            // Record the gate-accepted fact against the pass ledger so the
+            // distiller can report how many facts a pass committed.
+            ledger_record_stored(pass_id);
+            MemoryResponse::FactWrite(super::FactWriteOutcome {
+                stored: true,
+                quarantined: false,
+                confidence,
+                node_id: Some(node_id),
+            })
+        }
+        Ok(FactGateDecision::Quarantined { confidence }) => {
+            MemoryResponse::FactWrite(super::FactWriteOutcome {
+                stored: false,
+                quarantined: true,
+                confidence,
+                node_id: None,
+            })
+        }
+        Err(e) => MemoryResponse::Error(e.to_string()),
+    }
+}
diff --git a/src/memory_ipc/server/server_gate_tests.rs b/src/memory_ipc/server/server_gate_tests.rs
new file mode 100644
index 00000000..f78c5e0f
--- /dev/null
+++ b/src/memory_ipc/server/server_gate_tests.rs
@@ -0,0 +1,259 @@
+//! TDD (RED) tests for the server-side write-boundary gate (issue #2679, gate
+//! seam #1 of 2).
+//!
+//! When the distiller agentic step commits a fact through the daemon socket, the
+//! IPC **server** — not the client, not Simard's distillation module — is the
+//! single authoritative gate. The `StoreFactGated` dispatch arm must, per fact:
+//!
+//!   1. **Ground** the fact by confirming at least one of its
+//!      `source_episode_ids` resolves to a real episode node in the store (a
+//!      store-existence check via `CognitiveMemoryOps::episode_exists`), then
+//!   2. **Score** it with the shared `crate::fact_reliability` scorer using that
+//!      resolved `grounded` flag (NEVER the client's `confidence` hint), then
+//!   3. **Quarantine** anything below `RELIABILITY_THRESHOLD` (ungrounded,
+//!      empty-content, …) — writing nothing, and
+//!   4. **Dedup**: never let a weaker-or-equal restatement clobber an existing
+//!      equal-or-stronger fact of the same identity, then
+//!   5. **Persist** survivors via `store_fact_with_provenance` with the
+//!      *server-computed* confidence and the source-episode provenance edges.
+//!
+//! The disposition flows back as `MemoryResponse::FactWrite(FactWriteOutcome)`
+//! — there is no document for Simard to deserialize anywhere in the path, so the
+//! trailing-comma / noisy-stdout parse-failure mode of #2658/#2679 is
+//! structurally impossible here.
+//!
+//! These tests call the private `super::dispatch` directly against a real
+//! in-memory library backend and assert observable outcomes. They reference
+//! `MemoryRequest::StoreFactGated`, `MemoryResponse::FactWrite`, and
+//! `episode_exists`, none of which exist yet — the intended TDD red signal.
+//!
+//! Case IDs map to the design's security test plan: SEC-T1 (ungrounded),
+//! SEC-T2 (empty content), SEC-T3 (grounded happy path), SEC-T5 (dedup).
+
+use crate::cognitive_memory::{CognitiveMemoryOps, LibraryCognitiveMemory};
+
+use super::dispatch;
+use crate::memory_ipc::{FactWriteOutcome, MemoryRequest, MemoryResponse};
+
+/// Build a `StoreFactGated` request with a single source episode id and a
+/// deliberately optimistic client confidence the server must ignore.
+fn gated(concept: &str, content: &str, source_episode_id: &str) -> MemoryRequest {
+    MemoryRequest::StoreFactGated {
+        concept: concept.into(),
+        content: content.into(),
+        confidence: 0.99, // hostile hint — server must re-derive
+        tags: vec![concept.into()],
+        source_id: format!("distill:{source_episode_id}"),
+        source_episode_ids: vec![source_episode_id.into()],
+        pass_id: "pass-gate-test".into(),
+    }
+}
+
+fn expect_fact_write(resp: MemoryResponse) -> FactWriteOutcome {
+    match resp {
+        MemoryResponse::FactWrite(o) => o,
+        other => panic!("expected FactWrite response, got {other:?}"),
+    }
+}
+
+// ── SEC-T3: grounded, known-concept, well-formed fact is stored ─────────────
+
+#[test]
+fn sec_t3_grounded_known_concept_fact_is_stored_with_server_confidence() {
+    let mem = LibraryCognitiveMemory::in_memory().expect("in-memory db");
+    let episode_id = mem
+        .store_episode(
+            "empty outcome list panicked the cycle",
+            "engineer-cycle",
+            None,
+        )
+        .expect("store_episode");
+
+    let resp = dispatch(
+        &mem as &dyn CognitiveMemoryOps,
+        gated(
+            "bug-pattern",
+            "empty outcome list panics cycle",
+            &episode_id,
+        ),
+    );
+    let outcome = expect_fact_write(resp);
+
+    assert!(
+        outcome.stored,
+        "grounded, well-formed, known-concept fact must be stored"
+    );
+    assert!(!outcome.quarantined);
+    assert!(
+        (outcome.confidence - 0.9).abs() < 1e-9,
+        "server must persist its OWN computed confidence (0.9), not the client's 0.99; got {}",
+        outcome.confidence
+    );
+
+    let facts = mem.search_facts("bug-pattern", 10, 0.0).expect("search");
+    let stored = facts
+        .iter()
+        .find(|f| f.content == "empty outcome list panics cycle")
+        .expect("the stored fact must be retrievable");
+    assert!(
+        (stored.confidence - 0.9).abs() < 1e-9,
+        "the persisted fact must carry the server-computed confidence, not the client hint"
+    );
+}
+
+// ── SEC-T1: ungrounded fact is quarantined regardless of client confidence ──
+
+#[test]
+fn sec_t1_ungrounded_fact_is_quarantined_even_with_high_client_confidence() {
+    let mem = LibraryCognitiveMemory::in_memory().expect("in-memory db");
+    // No episode with this id exists → episode_exists must return false →
+    // ungrounded → score tops out at 0.4 < 0.5 → quarantined. The client's
+    // confidence of 0.99 must NOT rescue it.
+    let resp = dispatch(
+        &mem as &dyn CognitiveMemoryOps,
+        gated(
+            "bug-pattern",
+            "three or more words here",
+            "epi_ghost_never_stored",
+        ),
+    );
+    let outcome = expect_fact_write(resp);
+
+    assert!(!outcome.stored, "an ungrounded fact must never be stored");
+    assert!(
+        outcome.quarantined,
+        "an ungrounded fact must be quarantined"
+    );
+
+    let facts = mem.search_facts("bug-pattern", 10, 0.0).expect("search");
+    assert!(
+        facts.is_empty(),
+        "no ungrounded fact may leak into semantic memory (anti-hallucination boundary)"
+    );
+}
+
+// ── SEC-T2: empty / whitespace content is a hard quarantine even if grounded ─
+
+#[test]
+fn sec_t2_empty_content_is_quarantined_even_when_grounded() {
+    let mem = LibraryCognitiveMemory::in_memory().expect("in-memory db");
+    let episode_id = mem
+        .store_episode("some real episode content", "engineer-cycle", None)
+        .expect("store_episode");
+
+    for empty in ["", "   \t\n "] {
+        let resp = dispatch(
+            &mem as &dyn CognitiveMemoryOps,
+            gated("bug-pattern", empty, &episode_id),
+        );
+        let outcome = expect_fact_write(resp);
+        assert!(
+            !outcome.stored && outcome.quarantined,
+            "grounded-but-empty content must be quarantined (hard gate), content={empty:?}"
+        );
+    }
+
+    let facts = mem.search_facts("bug-pattern", 10, 0.0).expect("search");
+    assert!(facts.is_empty(), "no empty-content fact may be stored");
+}
+
+// ── SEC-T5: dedup — an equal-or-stronger prior is never clobbered ───────────
+
+#[test]
+fn sec_t5_equal_or_stronger_prior_is_not_clobbered() {
+    let mem = LibraryCognitiveMemory::in_memory().expect("in-memory db");
+    let episode_id = mem
+        .store_episode(
+            "empty outcome list panicked the cycle",
+            "engineer-cycle",
+            None,
+        )
+        .expect("store_episode");
+
+    // First write stores the fact at the server-computed 0.9.
+    let first = expect_fact_write(dispatch(
+        &mem as &dyn CognitiveMemoryOps,
+        gated(
+            "bug-pattern",
+            "empty outcome list panics cycle",
+            &episode_id,
+        ),
+    ));
+    assert!(first.stored, "the first grounded fact must be stored");
+
+    // An identical restatement scores the same 0.9; the existing fact is
+    // equal-or-stronger, so the gate must NOT downgrade/duplicate it.
+    let second = expect_fact_write(dispatch(
+        &mem as &dyn CognitiveMemoryOps,
+        gated(
+            "bug-pattern",
+            "empty outcome list panics cycle",
+            &episode_id,
+        ),
+    ));
+    assert!(
+        !second.stored,
+        "a duplicate of an equal-or-stronger existing fact must not be re-stored"
+    );
+
+    let facts: Vec<_> = mem
+        .search_facts("bug-pattern", 10, 0.0)
+        .expect("search")
+        .into_iter()
+        .filter(|f| f.content == "empty outcome list panics cycle")
+        .collect();
+    assert_eq!(
+        facts.len(),
+        1,
+        "dedup must keep exactly one copy of the fact, not accumulate restatements"
+    );
+}
+
+// ── Off-spec concept still stores when grounded + well-formed (concept is a
+//    nudge, not a gate) ───────────────────────────────────────────────────────
+
+#[test]
+fn grounded_offspec_concept_still_stores() {
+    let mem = LibraryCognitiveMemory::in_memory().expect("in-memory db");
+    let episode_id = mem
+        .store_episode("observed a novel thing", "engineer-cycle", None)
+        .expect("store_episode");
+
+    let outcome = expect_fact_write(dispatch(
+        &mem as &dyn CognitiveMemoryOps,
+        gated("observation", "three or more words here", &episode_id),
+    ));
+    assert!(
+        outcome.stored,
+        "a grounded, well-worded fact clears the gate at 0.8 even with an off-spec concept"
+    );
+    assert!(
+        (outcome.confidence - 0.8).abs() < 1e-9,
+        "off-spec concept loses only the 0.1 concept weight; got {}",
+        outcome.confidence
+    );
+}
+
+// ── The gate never emits a legacy "parse" response and never trusts the client
+//    confidence to promote an ungrounded fact ────────────────────────────────
+
+#[test]
+fn client_confidence_cannot_promote_across_the_gate() {
+    let mem = LibraryCognitiveMemory::in_memory().expect("in-memory db");
+    // Grounded but 1-word content: server score = 0.5 grounding + 0.15 short +
+    // 0.1 concept = 0.75, independent of the client's 0.99. We assert the
+    // reported confidence is the server's, proving the hint is discarded.
+    let episode_id = mem
+        .store_episode("short", "engineer-cycle", None)
+        .expect("store_episode");
+    let outcome = expect_fact_write(dispatch(
+        &mem as &dyn CognitiveMemoryOps,
+        gated("pr-pattern", "squash", &episode_id),
+    ));
+    assert!(outcome.stored);
+    assert!(
+        (outcome.confidence - 0.75).abs() < 1e-9,
+        "server confidence for grounded 1-word known-concept must be 0.75, not the client 0.99; got {}",
+        outcome.confidence
+    );
+}
diff --git a/src/memory_ipc/tests_gated_write_2679.rs b/src/memory_ipc/tests_gated_write_2679.rs
new file mode 100644
index 00000000..66e122d0
--- /dev/null
+++ b/src/memory_ipc/tests_gated_write_2679.rs
@@ -0,0 +1,503 @@
+//! TDD (RED) tests for the additive IPC surface that carries the #2679 semantic
+//! agent→agent handoff.
+//!
+//! Post-#2679 the distiller agentic step no longer prints a `{ "facts": [...] }`
+//! envelope for Simard to scrape back out of noisy recipe stdout. Instead it
+//! writes each fact DIRECTLY through the cognitive-memory write boundary. That
+//! boundary is the OODA daemon's memory IPC socket, extended here with two
+//! **additive** requests and one response variant:
+//!
+//!   * `MemoryRequest::StoreFactGated` — a per-fact write that the *server*
+//!     grounds, scores, clamps, dedups, and either stores or quarantines. The
+//!     server is the single authoritative gate: it never trusts the client's
+//!     `confidence` or `source_episode_ids` as fact.
+//!   * `MemoryRequest::StoreProcedureProvenance` — a procedure write carrying
+//!     its source episode ids for the `PROCEDURE_DERIVES_FROM` edge.
+//!   * `MemoryResponse::FactWrite(FactWriteOutcome)` — reports the *server's*
+//!     disposition (`stored` / `quarantined`) and the confidence it computed, so
+//!     the caller (and the `simard memory remember` CLI) can surface the result
+//!     WITHOUT any document for Simard to deserialize.
+//!
+//! The pre-existing variants (`Ping`, `StoreFact`, …) are untouched — this is a
+//! back-compatible extension, so the stub and legacy runners keep working.
+//!
+//! These tests reference symbols that do not exist yet
+//! (`StoreFactGated`, `StoreProcedureProvenance`, `FactWriteOutcome`,
+//! `MAX_FRAME`, `RemoteCognitiveMemory::remember_fact_gated`, …); the
+//! unresolved-path / missing-variant errors are the intended TDD red signal.
+
+// `MAX_FRAME` is a compile-time constant, so the bound-window assertions in
+// `max_frame_cap_is_bounded_and_generous_for_one_fact` are constant-valued by
+// design — that IS the contract (pin the const's sane window). Allow the lint so
+// the `-D warnings` gate stays green without weakening the assertion.
+#![allow(clippy::assertions_on_constants)]
+
+use std::io::Cursor;
+use std::sync::Arc;
+use std::time::Duration;
+
+use crate::cognitive_memory::{CognitiveMemoryOps, LibraryCognitiveMemory};
+
+use super::{
+    FactWriteOutcome, MAX_FRAME, MemoryRequest, MemoryResponse, RemoteCognitiveMemory, read_frame,
+    spawn_server, write_frame,
+};
+
+// ───────────────────────────────────────────────────────────────────────────
+// Additive protocol variants round-trip through serde unchanged
+// ───────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn store_fact_gated_round_trips_all_fields() {
+    let req = MemoryRequest::StoreFactGated {
+        concept: "bug-pattern".into(),
+        content: "empty outcome list panics cycle".into(),
+        // A hostile/optimistic client confidence the server must IGNORE.
+        confidence: 0.99,
+        tags: vec!["bug-pattern".into()],
+        source_id: "distill:epi_00007".into(),
+        source_episode_ids: vec!["epi_00007".into()],
+        pass_id: "pass-abc123".into(),
+    };
+    let bytes = serde_json::to_vec(&req).expect("serialize");
+    let back: MemoryRequest = serde_json::from_slice(&bytes).expect("deserialize");
+    match back {
+        MemoryRequest::StoreFactGated {
+            concept,
+            content,
+            confidence,
+            tags,
+            source_id,
+            source_episode_ids,
+            pass_id,
+        } => {
+            assert_eq!(concept, "bug-pattern");
+            assert_eq!(content, "empty outcome list panics cycle");
+            assert_eq!(confidence, 0.99);
+            assert_eq!(tags, vec!["bug-pattern".to_string()]);
+            assert_eq!(source_id, "distill:epi_00007");
+            assert_eq!(source_episode_ids, vec!["epi_00007".to_string()]);
+            assert_eq!(pass_id, "pass-abc123");
+        }
+        other => panic!("expected StoreFactGated, got {other:?}"),
+    }
+}
+
+#[test]
+fn store_procedure_provenance_round_trips_all_fields() {
+    let req = MemoryRequest::StoreProcedureProvenance {
+        name: "ci-fix:auto".into(),
+        steps: vec!["re-run".into(), "inspect logs".into()],
+        prerequisites: vec![],
+        source_episode_ids: vec!["epi_1".into(), "epi_2".into()],
+        pass_id: "pass-abc123".into(),
+    };
+    let bytes = serde_json::to_vec(&req).expect("serialize");
+    let back: MemoryRequest = serde_json::from_slice(&bytes).expect("deserialize");
+    match back {
+        MemoryRequest::StoreProcedureProvenance {
+            name,
+            steps,
+            source_episode_ids,
+            ..
+        } => {
+            assert_eq!(name, "ci-fix:auto");
+            assert_eq!(steps.len(), 2);
+            assert_eq!(
+                source_episode_ids,
+                vec!["epi_1".to_string(), "epi_2".to_string()]
+            );
+        }
+        other => panic!("expected StoreProcedureProvenance, got {other:?}"),
+    }
+}
+
+#[test]
+fn fact_write_response_round_trips() {
+    let resp = MemoryResponse::FactWrite(FactWriteOutcome {
+        stored: true,
+        quarantined: false,
+        confidence: 0.9,
+        node_id: Some("sem_42".into()),
+    });
+    let bytes = serde_json::to_vec(&resp).expect("serialize");
+    let back: MemoryResponse = serde_json::from_slice(&bytes).expect("deserialize");
+    match back {
+        MemoryResponse::FactWrite(o) => {
+            assert!(o.stored);
+            assert!(!o.quarantined);
+            assert_eq!(o.confidence, 0.9);
+            assert_eq!(o.node_id.as_deref(), Some("sem_42"));
+        }
+        other => panic!("expected FactWrite, got {other:?}"),
+    }
+}
+
+/// The existing variants must still round-trip after the additive extension —
+/// belt-and-suspenders that the new arms did not perturb the serde tag layout.
+#[test]
+fn preexisting_store_fact_variant_unaffected_by_extension() {
+    let req = MemoryRequest::StoreFact {
+        concept: "gravity".into(),
+        content: "things fall".into(),
+        confidence: 0.9,
+        tags: vec!["physics".into()],
+        source_id: "src-1".into(),
+    };
+    let bytes = serde_json::to_vec(&req).unwrap();
+    let back: MemoryRequest = serde_json::from_slice(&bytes).unwrap();
+    assert!(matches!(back, MemoryRequest::StoreFact { .. }));
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// DOS-1: read_frame must reject an oversized length prefix (MAX_FRAME cap)
+// ───────────────────────────────────────────────────────────────────────────
+
+/// A hostile / corrupt client can send a 4-byte length prefix claiming a
+/// multi-gigabyte body. Pre-#2679 `read_frame` did `vec![0u8; len]` and would
+/// try to allocate it. The hardened frame reader must reject any length that
+/// exceeds `MAX_FRAME` BEFORE allocating or reading the body.
+#[test]
+fn read_frame_rejects_length_over_max_frame() {
+    let bogus_len = (MAX_FRAME as u64 + 1) as u32; // just over the cap
+    let mut framed = Vec::new();
+    framed.extend_from_slice(&bogus_len.to_be_bytes());
+    // Deliberately provide NO body — a correct implementation rejects on the
+    // length alone and never blocks trying to read `bogus_len` bytes.
+    let mut cursor = Cursor::new(framed);
+    let result = read_frame(&mut cursor);
+    assert!(
+        result.is_err(),
+        "read_frame must reject a length prefix exceeding MAX_FRAME without allocating the body"
+    );
+}
+
+/// A frame at or under the cap still round-trips: the cap only rejects abuse,
+/// never legitimate per-fact payloads (a single fact is a few hundred bytes).
+#[test]
+fn write_then_read_frame_round_trips_under_cap() {
+    let payload = br#"{"op":"ping"}"#;
+    assert!(
+        payload.len() < MAX_FRAME,
+        "test payload must be under the cap"
+    );
+    let mut buf = Vec::new();
+    write_frame(&mut buf, payload).expect("write_frame");
+    let mut cursor = Cursor::new(buf);
+    let got = read_frame(&mut cursor).expect("read_frame under cap must succeed");
+    assert_eq!(got, payload);
+}
+
+#[test]
+fn max_frame_cap_is_bounded_and_generous_for_one_fact() {
+    // The cap must be large enough for a single distilled fact (well under a
+    // megabyte) yet small enough to bound a malicious allocation. Pin a sane
+    // window rather than an exact value so tuning stays free.
+    assert!(
+        MAX_FRAME >= 64 * 1024,
+        "MAX_FRAME must comfortably fit one fact write"
+    );
+    assert!(
+        MAX_FRAME <= 64 * 1024 * 1024,
+        "MAX_FRAME must bound a hostile allocation"
+    );
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Client wrapper: remember_fact_gated round-trips through a real server + gate
+// ───────────────────────────────────────────────────────────────────────────
+
+/// Spin up a real IPC server over an in-memory library backend, store a real
+/// episode so the fact is *grounded* by store-existence, then commit a fact via
+/// the new inherent client wrapper. The server gate stores it and reports the
+/// disposition — with NO envelope for Simard to parse anywhere in the path.
+#[test]
+fn remember_fact_gated_stores_a_grounded_fact_end_to_end() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("memory.sock");
+    let mem: Arc<dyn CognitiveMemoryOps> =
+        Arc::new(LibraryCognitiveMemory::in_memory().expect("in-memory db"));
+
+    // Seed a real episode; its returned id is what makes a citing fact grounded.
+    let episode_id = mem
+        .store_episode(
+            "empty outcome list panicked the cycle",
+            "engineer-cycle",
+            None,
+        )
+        .expect("store_episode");
+
+    let _handle = spawn_server(sock.clone(), Arc::clone(&mem)).expect("spawn server");
+    for _ in 0..50 {
+        if sock.exists() {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(20));
+    }
+
+    let client = RemoteCognitiveMemory::connect(&sock).expect("connect");
+    let outcome = client
+        .remember_fact_gated(
+            "bug-pattern",
+            "empty outcome list panics cycle",
+            // Client-supplied confidence is a hint the server must not trust.
+            0.99,
+            &["bug-pattern".to_string()],
+            "distill:something",
+            std::slice::from_ref(&episode_id),
+            "pass-xyz",
+        )
+        .expect("remember_fact_gated call");
+
+    assert!(
+        outcome.stored,
+        "a grounded, well-formed fact must be stored"
+    );
+    assert!(!outcome.quarantined);
+    // The server RE-derived confidence from the gate, not the client's 0.99.
+    assert!(
+        (outcome.confidence - 0.9).abs() < 1e-9,
+        "server must report its own computed confidence (0.9), not the client hint; got {}",
+        outcome.confidence
+    );
+
+    // The fact is now retrievable — proving it really reached semantic memory.
+    let facts = client.search_facts("bug-pattern", 10, 0.0).expect("search");
+    assert!(
+        facts
+            .iter()
+            .any(|f| f.content == "empty outcome list panics cycle"),
+        "the committed fact must be present in semantic memory"
+    );
+}
+
+/// A fact citing an episode id that does NOT exist in the store is ungrounded
+/// and must be quarantined by the server gate — even though the client claimed
+/// a high confidence. This is the anti-hallucination guarantee at the boundary.
+#[test]
+fn remember_fact_gated_quarantines_an_ungrounded_fact() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("memory.sock");
+    let mem: Arc<dyn CognitiveMemoryOps> =
+        Arc::new(LibraryCognitiveMemory::in_memory().expect("in-memory db"));
+    let _handle = spawn_server(sock.clone(), Arc::clone(&mem)).expect("spawn server");
+    for _ in 0..50 {
+        if sock.exists() {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(20));
+    }
+
+    let client = RemoteCognitiveMemory::connect(&sock).expect("connect");
+    let outcome = client
+        .remember_fact_gated(
+            "bug-pattern",
+            "three or more words here",
+            0.99,
+            &[],
+            "distill:ghost",
+            &["epi_does_not_exist".to_string()],
+            "pass-xyz",
+        )
+        .expect("remember_fact_gated call");
+
+    assert!(!outcome.stored, "an ungrounded fact must not be stored");
+    assert!(
+        outcome.quarantined,
+        "an ungrounded fact must be quarantined"
+    );
+
+    let facts = client.search_facts("bug-pattern", 10, 0.0).expect("search");
+    assert!(
+        facts.is_empty(),
+        "no ungrounded fact may leak into semantic memory"
+    );
+}
+
+/// The procedure wrapper commits through the provenance write path and returns
+/// the new node id (no document to parse).
+#[test]
+fn remember_procedure_provenance_returns_an_id() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("memory.sock");
+    let mem: Arc<dyn CognitiveMemoryOps> =
+        Arc::new(LibraryCognitiveMemory::in_memory().expect("in-memory db"));
+    let episode_id = mem
+        .store_episode(
+            "re-ran ci, inspected logs, fixed flake",
+            "engineer-cycle",
+            None,
+        )
+        .expect("store_episode");
+    let _handle = spawn_server(sock.clone(), Arc::clone(&mem)).expect("spawn server");
+    for _ in 0..50 {
+        if sock.exists() {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(20));
+    }
+
+    let client = RemoteCognitiveMemory::connect(&sock).expect("connect");
+    let id = client
+        .remember_procedure_provenance(
+            "ci-fix:auto",
+            &["re-run".to_string(), "inspect logs".to_string()],
+            &[],
+            std::slice::from_ref(&episode_id),
+            "pass-xyz",
+        )
+        .expect("remember_procedure_provenance call");
+    assert!(
+        !id.is_empty(),
+        "a stored procedure must return a non-empty id"
+    );
+}
+
+/// Grounding symmetry with the fact gate (issue #2679): a procedure that CITES
+/// source episodes none of which resolve has fabricated provenance and MUST be
+/// rejected server-side — its `PROCEDURE_DERIVES_FROM` edges would otherwise
+/// dangle. (A procedure citing no sources is unaffected; there is nothing to
+/// fabricate.)
+#[test]
+fn remember_procedure_provenance_rejects_ungrounded_provenance() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("memory.sock");
+    let mem: Arc<dyn CognitiveMemoryOps> =
+        Arc::new(LibraryCognitiveMemory::in_memory().expect("in-memory db"));
+    let _handle = spawn_server(sock.clone(), Arc::clone(&mem)).expect("spawn server");
+    for _ in 0..50 {
+        if sock.exists() {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(20));
+    }
+
+    let client = RemoteCognitiveMemory::connect(&sock).expect("connect");
+    let result = client.remember_procedure_provenance(
+        "ci-fix:ghost",
+        &["re-run".to_string()],
+        &[],
+        &["epi_does_not_exist".to_string()],
+        "pass-xyz",
+    );
+    assert!(
+        result.is_err(),
+        "a procedure whose cited provenance does not resolve must be rejected"
+    );
+
+    // Nothing leaked into procedural memory.
+    let procs = client.recall_procedure("ci-fix", 10).expect("recall");
+    assert!(
+        procs.is_empty(),
+        "no ungrounded procedure may leak into procedural memory"
+    );
+}
+
+/// Batch grounding (issue #2679): a fact grounds iff *at least one* of its cited
+/// episode ids resolves. This pins the `any_episode_exists` batch semantics — a
+/// mix of a bogus id and a real id must still ground (and store) the fact.
+#[test]
+fn remember_fact_gated_grounds_when_any_cited_episode_resolves() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("memory.sock");
+    let mem: Arc<dyn CognitiveMemoryOps> =
+        Arc::new(LibraryCognitiveMemory::in_memory().expect("in-memory db"));
+    let real_id = mem
+        .store_episode("observed a real failure", "engineer-cycle", None)
+        .expect("store_episode");
+    let _handle = spawn_server(sock.clone(), Arc::clone(&mem)).expect("spawn server");
+    for _ in 0..50 {
+        if sock.exists() {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(20));
+    }
+
+    let client = RemoteCognitiveMemory::connect(&sock).expect("connect");
+    let outcome = client
+        .remember_fact_gated(
+            "bug-pattern",
+            "grounded via one real cited episode",
+            0.0,
+            &["bug-pattern".to_string()],
+            "distill:mixed",
+            &["epi_does_not_exist".to_string(), real_id.clone()],
+            "pass-mixed",
+        )
+        .expect("remember_fact_gated call");
+
+    assert!(
+        outcome.stored,
+        "a fact citing at least one resolving episode must be grounded and stored"
+    );
+    assert!(!outcome.quarantined);
+}
+
+/// Issue #2679 write ledger: the server counts facts the gate ACCEPTED for a
+/// distillation `pass_id`, and `drain_pass_ledger` returns then clears that
+/// count — the only way the distiller (which gets no returned document) can
+/// report how many facts a pass committed. A quarantined fact is NOT counted.
+#[test]
+fn drain_pass_ledger_returns_only_gate_accepted_facts_then_clears() {
+    let dir = tempfile::tempdir().unwrap();
+    let sock = dir.path().join("memory.sock");
+    let mem: Arc<dyn CognitiveMemoryOps> =
+        Arc::new(LibraryCognitiveMemory::in_memory().expect("in-memory db"));
+    let episode_id = mem
+        .store_episode(
+            "empty outcome list panicked the cycle",
+            "engineer-cycle",
+            None,
+        )
+        .expect("store_episode");
+    let _handle = spawn_server(sock.clone(), Arc::clone(&mem)).expect("spawn server");
+    for _ in 0..50 {
+        if sock.exists() {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(20));
+    }
+    let client = RemoteCognitiveMemory::connect(&sock).expect("connect");
+
+    // A process-unique pass id so this test never collides with the shared
+    // global ledger used by the other round-trip tests.
+    let pass_id = format!("ledger-test-{}", std::process::id());
+
+    // One grounded fact (accepted) and one ungrounded fact (quarantined).
+    let stored = client
+        .remember_fact_gated(
+            "bug-pattern",
+            "empty outcome list panics cycle",
+            0.99,
+            &["bug-pattern".to_string()],
+            "distill:x",
+            std::slice::from_ref(&episode_id),
+            &pass_id,
+        )
+        .expect("gated write");
+    assert!(stored.stored);
+    let quarantined = client
+        .remember_fact_gated(
+            "bug-pattern",
+            "three or more words here",
+            0.99,
+            &[],
+            "distill:ghost",
+            &["epi_does_not_exist".to_string()],
+            &pass_id,
+        )
+        .expect("gated write");
+    assert!(quarantined.quarantined);
+
+    // Only the accepted fact is counted; the drain returns it exactly once.
+    assert_eq!(
+        client.drain_pass_ledger(&pass_id).expect("drain"),
+        1,
+        "the ledger counts only gate-accepted facts for this pass"
+    );
+    assert_eq!(
+        client.drain_pass_ledger(&pass_id).expect("drain again"),
+        0,
+        "draining clears the pass entry — a second drain is empty"
+    );
+}
diff --git a/src/operator_cli/memory.rs b/src/operator_cli/memory.rs
index e8b3108a..8e634853 100644
--- a/src/operator_cli/memory.rs
+++ b/src/operator_cli/memory.rs
@@ -14,7 +14,7 @@ use std::path::{Path, PathBuf};
 use crate::cognitive_memory::CognitiveMemoryOps;
 use crate::error::SimardResult;
 use crate::memory_cognitive::{CognitiveStatistics, GraphStats};
-use crate::memory_ipc::{open_reader_client, socket_path_for};
+use crate::memory_ipc::{RemoteCognitiveMemory, open_reader_client, socket_path_for};
 
 pub(super) const MEMORY_HELP: &str = "\
 Simard memory subcommand — cognitive-memory introspection & restore
@@ -168,16 +168,382 @@ pub(crate) fn dispatch_memory_command(
         "stats" => run_stats(args),
         "dump" => run_dump(args),
         "import" => run_import(args),
+        "remember" => {
+            // The distiller's per-fact WRITE tool (issue #2679). `run_remember_fact`
+            // returns a precise exit code (0 stored / 2 usage / 3 no-daemon /
+            // 4 quarantined); honour it by exiting the process directly so a
+            // mis-invoking or blocked agent is diagnosable. `--help` short-circuits
+            // before any daemon contact.
+            let argv: Vec<String> = args.collect();
+            if argv
+                .iter()
+                .any(|a| a == "--help" || a == "-h" || a == "help")
+            {
+                print!("{REMEMBER_HELP}");
+                return Ok(());
+            }
+            std::process::exit(run_remember_fact(argv));
+        }
+        "remember-procedure" => {
+            let argv: Vec<String> = args.collect();
+            if argv
+                .iter()
+                .any(|a| a == "--help" || a == "-h" || a == "help")
+            {
+                print!("{REMEMBER_PROCEDURE_HELP}");
+                return Ok(());
+            }
+            std::process::exit(run_remember_procedure(argv));
+        }
         other => Err(format!("unsupported command 'memory {other}'").into()),
     }
 }
 
+// ───────────────────────────────────────────────────────────────────────────
+// `simard memory remember` — the distiller's per-fact WRITE tool (issue #2679)
+// ───────────────────────────────────────────────────────────────────────────
+
+// Process exit codes for the `remember` / `remember-procedure` write tools
+// (issue #2679). Named so a mis-invoking or blocked distiller agent is
+// diagnosable from the exit status alone, and so every `return` site reads its
+// intent instead of a bare integer.
+//
+// Note on the shared `EXIT_NO_DAEMON` (3): a failed daemon round-trip — whether
+// the socket was unreachable OR the gated write itself errored — is reported
+// with the *same* code on purpose. Both mean "the write never committed via the
+// daemon"; they are deliberately distinct from `EXIT_QUARANTINED` (4), which is
+// a *successful* round-trip whose gate disposition was "rejected". Collapsing
+// the two transport-failure cases keeps the documented, stable exit-code
+// contract (0/2/3/4) rather than proliferating codes for callers to branch on.
+
+/// The fact/procedure cleared the gate and was persisted.
+const EXIT_STORED: i32 = 0;
+/// A required flag was missing or malformed.
+const EXIT_USAGE: i32 = 2;
+/// The daemon write round-trip did not commit: no reachable daemon, or the
+/// gated write itself returned an error. There is no un-gated fallback.
+const EXIT_NO_DAEMON: i32 = 3;
+/// The gate completed a round-trip and blocked the fact
+/// (ungrounded / empty / below the reliability threshold).
+const EXIT_QUARANTINED: i32 = 4;
+
+const REMEMBER_HELP: &str = "\
+Simard memory remember — write ONE semantic fact into cognitive memory.
+
+Usage:
+  simard memory remember --concept <LABEL> --content <TEXT>
+        [--source-episode-id <ID> ...] [--confidence <0..1>]
+        [--tags <a,b,c>] [--pass-id <ID>] [state-root]
+
+One process writes exactly one fact. There is no batch/array/JSON-body form —
+that is the point of #2679: no Simard-side document is ever deserialized. Emit N
+facts with N calls.
+
+The write routes ONLY through the OODA daemon's memory socket, where the single
+authoritative write-boundary gate grounds, scores, quarantines, and dedups the
+fact server-side. The client-supplied --confidence is a hint the server ignores;
+the server re-derives confidence from provenance grounding + content + concept.
+
+Exit codes:
+  0  stored          the fact cleared the gate and was persisted
+  2  usage error     a required flag was missing or malformed
+  3  no daemon       no reachable memory daemon (no un-gated fallback exists)
+  4  quarantined     the gate blocked the fact (ungrounded/empty/below threshold)
+";
+
+const REMEMBER_PROCEDURE_HELP: &str = "\
+Simard memory remember-procedure — write ONE procedure into cognitive memory.
+
+Usage:
+  simard memory remember-procedure --name <NAME> --step <TEXT> [--step <TEXT> ...]
+        [--prerequisite <TEXT> ...] [--source-episode-id <ID> ...]
+        [--pass-id <ID>] [state-root]
+
+Exit codes: 0 stored, 2 usage error, 3 no reachable daemon.
+";
+
+/// Parsed `simard memory remember` invocation (issue #2679). Scalar flags only —
+/// one process writes one fact, so there is no envelope to deserialize.
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct RememberFactArgs {
+    pub concept: String,
+    pub content: String,
+    pub source_episode_ids: Vec<String>,
+    /// A hint only; the server re-derives the stored confidence.
+    pub confidence: Option<f64>,
+    pub tags: Vec<String>,
+    pub pass_id: Option<String>,
+    pub state_root: Option<PathBuf>,
+}
+
+/// Take a flag's value: inline (`--flag=value`) if present, else the next argv
+/// token (`--flag value`). Errors if neither is available.
+fn flag_value(
+    flag: &str,
+    inline: Option<String>,
+    next: &mut dyn Iterator<Item = String>,
+) -> Result<String, String> {
+    match inline {
+        Some(v) => Ok(v),
+        None => next
+            .next()
+            .ok_or_else(|| format!("--{flag} requires a value")),
+    }
+}
+
+/// Parse `simard memory remember` argv into typed [`RememberFactArgs`], packing
+/// scalar flags straight into fields the CLI hands to a typed IPC request. No
+/// free text is ever re-parsed as JSON.
+pub(crate) fn parse_remember_fact_args(args: Vec<String>) -> Result<RememberFactArgs, String> {
+    let mut concept: Option<String> = None;
+    let mut content: Option<String> = None;
+    let mut source_episode_ids: Vec<String> = Vec::new();
+    let mut confidence: Option<f64> = None;
+    let mut tags: Vec<String> = Vec::new();
+    let mut pass_id: Option<String> = None;
+    let mut state_root: Option<PathBuf> = None;
+
+    let mut iter = args.into_iter();
+    while let Some(arg) = iter.next() {
+        if let Some(rest) = arg.strip_prefix("--") {
+            let (key, inline) = match rest.split_once('=') {
+                Some((k, v)) => (k.to_string(), Some(v.to_string())),
+                None => (rest.to_string(), None),
+            };
+            match key.as_str() {
+                "concept" => concept = Some(flag_value("concept", inline, &mut iter)?),
+                "content" => content = Some(flag_value("content", inline, &mut iter)?),
+                "source-episode-id" => {
+                    source_episode_ids.push(flag_value("source-episode-id", inline, &mut iter)?)
+                }
+                "confidence" => {
+                    let v = flag_value("confidence", inline, &mut iter)?;
+                    let parsed = v.parse::<f64>().map_err(|_| {
+                        format!("--confidence must be a number in [0,1], got {v:?}")
+                    })?;
+                    confidence = Some(parsed);
+                }
+                "tags" => {
+                    let v = flag_value("tags", inline, &mut iter)?;
+                    tags.extend(
+                        v.split(',')
+                            .map(|s| s.trim().to_string())
+                            .filter(|s| !s.is_empty()),
+                    );
+                }
+                "pass-id" => pass_id = Some(flag_value("pass-id", inline, &mut iter)?),
+                other => return Err(format!("unknown flag --{other}")),
+            }
+        } else if state_root.is_none() {
+            state_root = Some(PathBuf::from(arg));
+        } else {
+            return Err(format!("unexpected extra positional argument '{arg}'"));
+        }
+    }
+
+    let concept = concept.ok_or_else(|| "missing required --concept".to_string())?;
+    let content = content.ok_or_else(|| "missing required --content".to_string())?;
+    Ok(RememberFactArgs {
+        concept,
+        content,
+        source_episode_ids,
+        confidence,
+        tags,
+        pass_id,
+        state_root,
+    })
+}
+
+/// Run `simard memory remember`, returning the process exit code
+/// ([`EXIT_STORED`] / [`EXIT_USAGE`] / [`EXIT_NO_DAEMON`] / [`EXIT_QUARANTINED`]).
+/// Routes ONLY through the daemon socket: a direct on-disk open would bypass the
+/// authoritative gate, so no daemon means no gated write path.
+pub(crate) fn run_remember_fact(args: Vec<String>) -> i32 {
+    let parsed = match parse_remember_fact_args(args) {
+        Ok(p) => p,
+        Err(e) => {
+            eprintln!("[simard] memory remember: {e}");
+            return EXIT_USAGE;
+        }
+    };
+
+    let state_root = resolve_state_root(parsed.state_root.clone());
+    let sock = socket_path_for(&state_root);
+    let client = match RemoteCognitiveMemory::connect(&sock) {
+        Ok(c) => c,
+        Err(e) => {
+            eprintln!(
+                "[simard] memory remember: no reachable memory daemon at {} ({e}); \
+                 not writing un-gated",
+                sock.display()
+            );
+            return EXIT_NO_DAEMON;
+        }
+    };
+
+    // A stable provenance label for the fact's `source_id`; the gate verifies
+    // the episode ids separately for grounding.
+    let source_id = match parsed.source_episode_ids.first() {
+        Some(id) => format!("distill:{id}"),
+        None => "distill".to_string(),
+    };
+    let pass_id = resolve_pass_id(parsed.pass_id.as_deref());
+    // The confidence is a hint the server ignores; pass 0.0 when unset.
+    let confidence_hint = parsed.confidence.unwrap_or(0.0);
+
+    match client.remember_fact_gated(
+        &parsed.concept,
+        &parsed.content,
+        confidence_hint,
+        &parsed.tags,
+        &source_id,
+        &parsed.source_episode_ids,
+        &pass_id,
+    ) {
+        Ok(outcome) if outcome.stored => {
+            println!(
+                "[simard] memory remember: stored concept={} confidence={:.2}{}",
+                parsed.concept,
+                outcome.confidence,
+                outcome
+                    .node_id
+                    .as_deref()
+                    .map(|id| format!(" node_id={id}"))
+                    .unwrap_or_default()
+            );
+            EXIT_STORED
+        }
+        Ok(outcome) => {
+            eprintln!(
+                "[simard] memory remember: quarantined concept={} confidence={:.2} (below gate)",
+                parsed.concept, outcome.confidence
+            );
+            EXIT_QUARANTINED
+        }
+        Err(e) => {
+            eprintln!("[simard] memory remember: gated write failed: {e}");
+            EXIT_NO_DAEMON
+        }
+    }
+}
+
+/// Run `simard memory remember-procedure`, returning the process exit code
+/// (0 stored, 2 usage error, 3 no reachable daemon).
+pub(crate) fn run_remember_procedure(args: Vec<String>) -> i32 {
+    let mut name: Option<String> = None;
+    let mut steps: Vec<String> = Vec::new();
+    let mut prerequisites: Vec<String> = Vec::new();
+    let mut source_episode_ids: Vec<String> = Vec::new();
+    let mut pass_id: Option<String> = None;
+    let mut state_root: Option<PathBuf> = None;
+
+    let mut iter = args.into_iter();
+    while let Some(arg) = iter.next() {
+        if let Some(rest) = arg.strip_prefix("--") {
+            let (key, inline) = match rest.split_once('=') {
+                Some((k, v)) => (k.to_string(), Some(v.to_string())),
+                None => (rest.to_string(), None),
+            };
+            let res = match key.as_str() {
+                "name" => flag_value("name", inline, &mut iter).map(|v| name = Some(v)),
+                "step" => flag_value("step", inline, &mut iter).map(|v| steps.push(v)),
+                "prerequisite" => {
+                    flag_value("prerequisite", inline, &mut iter).map(|v| prerequisites.push(v))
+                }
+                "source-episode-id" => flag_value("source-episode-id", inline, &mut iter)
+                    .map(|v| source_episode_ids.push(v)),
+                "pass-id" => flag_value("pass-id", inline, &mut iter).map(|v| pass_id = Some(v)),
+                other => Err(format!("unknown flag --{other}")),
+            };
+            if let Err(e) = res {
+                eprintln!("[simard] memory remember-procedure: {e}");
+                return EXIT_USAGE;
+            }
+        } else if state_root.is_none() {
+            state_root = Some(PathBuf::from(arg));
+        } else {
+            eprintln!("[simard] memory remember-procedure: unexpected extra argument '{arg}'");
+            return EXIT_USAGE;
+        }
+    }
+
+    let name = match name {
+        Some(n) => n,
+        None => {
+            eprintln!("[simard] memory remember-procedure: missing required --name");
+            return EXIT_USAGE;
+        }
+    };
+    if steps.is_empty() {
+        eprintln!("[simard] memory remember-procedure: at least one --step is required");
+        return EXIT_USAGE;
+    }
+
+    let state_root = resolve_state_root(state_root);
+    let sock = socket_path_for(&state_root);
+    let client = match RemoteCognitiveMemory::connect(&sock) {
+        Ok(c) => c,
+        Err(e) => {
+            eprintln!(
+                "[simard] memory remember-procedure: no reachable memory daemon at {} ({e})",
+                sock.display()
+            );
+            return EXIT_NO_DAEMON;
+        }
+    };
+    let pass_id = resolve_pass_id(pass_id.as_deref());
+    match client.remember_procedure_provenance(
+        &name,
+        &steps,
+        &prerequisites,
+        &source_episode_ids,
+        &pass_id,
+    ) {
+        Ok(id) => {
+            println!("[simard] memory remember-procedure: stored name={name} node_id={id}");
+            EXIT_STORED
+        }
+        Err(e) => {
+            eprintln!("[simard] memory remember-procedure: write failed: {e}");
+            EXIT_NO_DAEMON
+        }
+    }
+}
+
 /// Resolve the state root: explicit argument wins, else the shared resolver
 /// the daemon uses (`$SIMARD_STATE_ROOT`, then `$HOME/.simard`).
 fn resolve_state_root(explicit: Option<PathBuf>) -> PathBuf {
     explicit.unwrap_or_else(crate::state_root::simard_state_root)
 }
 
+/// Resolve the distillation pass id for a `remember` / `remember-procedure`
+/// write (issue #2679).
+///
+/// Precedence: a non-empty explicit `--pass-id` flag wins; otherwise fall back
+/// to the [`DISTILL_PASS_ID_ENV`] environment variable the distill runner
+/// exports to every remember subprocess. An empty result (neither source set)
+/// means "no ledger participation" — the server's ledger deliberately no-ops.
+///
+/// The env fallback is the fix for the silent metrics-degradation regression:
+/// the distiller agent runs `simard memory remember` with only the content
+/// flags and no `--pass-id`, so without this fallback the pass id resolved
+/// empty, the server ledger dropped the write, and `drain_pass_ledger` returned
+/// 0 — making every distill pass report `fact_count = 0` / `reduction_pct =
+/// 100%` even though facts were stored. Only tests (which pass `--pass-id`
+/// explicitly) exercised the ledger, hiding the production breakage.
+fn resolve_pass_id(explicit: Option<&str>) -> String {
+    if let Some(p) = explicit
+        && !p.is_empty()
+    {
+        return p.to_string();
+    }
+    std::env::var(crate::memory_ipc::DISTILL_PASS_ID_ENV)
+        .ok()
+        .map(|v| v.trim().to_string())
+        .filter(|v| !v.is_empty())
+        .unwrap_or_default()
+}
+
 /// Best-effort access-tier label for the banner. The daemon socket is
 /// authoritative when present; otherwise the read is a direct on-disk open.
 fn access_tier_for(state_root: &Path) -> AccessTier {
@@ -594,11 +960,18 @@ fn render_json(report: &MemoryReport, include_samples: bool) -> String {
     serde_json::to_string_pretty(&value).unwrap_or_else(|_| value.to_string())
 }
 
+// TDD (RED) for issue #2679: tests for the agent-facing `simard memory remember`
+// write tool (scalar-flag parsing + exit codes + daemon-down). The subcommand,
+// `parse_remember_fact_args`, `RememberFactArgs`, and `run_remember_fact` land
+// in the implementation step; until then the unresolved paths are the red
+// signal. `#[cfg(test)]` so production builds never compile it.
+#[cfg(test)]
+mod remember_tests;
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::cognitive_memory::{CognitiveMemoryOps, LibraryCognitiveMemory};
-
     /// Seed a temp store with at least one row of every introspectable type so
     /// the report has non-zero counts to assert against.
     fn seeded_store() -> (tempfile::TempDir, LibraryCognitiveMemory) {
diff --git a/src/operator_cli/memory/remember_tests.rs b/src/operator_cli/memory/remember_tests.rs
new file mode 100644
index 00000000..9f24f477
--- /dev/null
+++ b/src/operator_cli/memory/remember_tests.rs
@@ -0,0 +1,358 @@
+//! TDD (RED) tests for the agent-facing `simard memory remember` /
+//! `remember-procedure` write tool (issue #2679).
+//!
+//! This CLI subcommand is the mechanism by which the distiller agentic step
+//! commits facts DIRECTLY to cognitive memory — one process invocation writes
+//! exactly one fact through the authoritative IPC gate. There is no `{ "facts":
+//! [...] }` envelope, so nothing Simard hand-parses.
+//!
+//! Contract pinned here:
+//!
+//!   * **Scalar flags, no envelope.** `--concept`, `--content`,
+//!     `--source-episode-id` (repeatable), `--confidence`, `--tags`,
+//!     `--pass-id`, optional positional state-root. One process = one fact.
+//!   * **Routes ONLY through the daemon socket** (`socket_path_for` →
+//!     `RemoteCognitiveMemory::connect` → `StoreFactGated`). There is
+//!     deliberately NO direct-open fallback: a direct open would bypass the
+//!     server-side gate (the single authoritative write boundary), so if no
+//!     daemon is reachable the tool exits **3** rather than silently writing
+//!     ungated.
+//!   * **Exit codes:** 0 = stored, 2 = usage/arg error, 3 = no reachable memory
+//!     daemon, 4 = the gate quarantined the fact.
+//!
+//! These tests reference `parse_remember_fact_args`, `RememberFactArgs`, and
+//! `run_remember_fact`, none of which exist yet — the intended TDD red signal.
+//! The `remember` / `remember-procedure` subcommands are also not yet routed in
+//! `dispatch_memory_command`, so the dispatch-recognition test currently takes
+//! the "unsupported command" path (runtime red).
+
+use serial_test::serial;
+
+use super::{
+    RememberFactArgs, dispatch_memory_command, parse_remember_fact_args, resolve_pass_id,
+    run_remember_fact,
+};
+
+/// RAII env guard so the daemon-down test cannot be perturbed by a
+/// `SIMARD_MEMORY_SOCKET` override pointing at a live socket.
+struct EnvGuard {
+    key: &'static str,
+    prev: Option<std::ffi::OsString>,
+}
+impl EnvGuard {
+    fn unset(key: &'static str) -> Self {
+        let prev = std::env::var_os(key);
+        unsafe {
+            std::env::remove_var(key);
+        }
+        Self { key, prev }
+    }
+
+    /// Set `key` to `value` for the guard's lifetime, restoring the prior value
+    /// (or unset state) on drop. Used to inject `SIMARD_DISTILL_PASS_ID` /
+    /// `SIMARD_MEMORY_SOCKET` for the real-distill-path regression test.
+    fn set(key: &'static str, value: &str) -> Self {
+        let prev = std::env::var_os(key);
+        unsafe {
+            std::env::set_var(key, value);
+        }
+        Self { key, prev }
+    }
+}
+impl Drop for EnvGuard {
+    fn drop(&mut self) {
+        unsafe {
+            match self.prev.take() {
+                Some(v) => std::env::set_var(self.key, v),
+                None => std::env::remove_var(self.key),
+            }
+        }
+    }
+}
+
+fn argv(parts: &[&str]) -> Vec<String> {
+    parts.iter().map(|s| s.to_string()).collect()
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Argument parsing — scalar flags, no envelope
+// ───────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn parse_accepts_a_full_fact_invocation() {
+    let args: RememberFactArgs = parse_remember_fact_args(argv(&[
+        "--concept=bug-pattern",
+        "--content=empty outcome list panics cycle",
+        "--source-episode-id=epi_00007",
+        "--confidence=0.8",
+        "--tags=bug-pattern,regression",
+        "--pass-id=pass-abc123",
+    ]))
+    .expect("a fully-specified fact invocation must parse");
+
+    assert_eq!(args.concept, "bug-pattern");
+    assert_eq!(args.content, "empty outcome list panics cycle");
+    assert_eq!(args.source_episode_ids, vec!["epi_00007".to_string()]);
+    assert_eq!(args.confidence, Some(0.8));
+    assert_eq!(
+        args.tags,
+        vec!["bug-pattern".to_string(), "regression".to_string()]
+    );
+    assert_eq!(args.pass_id.as_deref(), Some("pass-abc123"));
+    assert!(args.state_root.is_none(), "no positional state-root given");
+}
+
+#[test]
+fn parse_accepts_repeated_source_episode_ids() {
+    // Procedures/facts may derive from multiple episodes; the flag repeats.
+    let args = parse_remember_fact_args(argv(&[
+        "--concept=lesson-learned",
+        "--content=three or more words here",
+        "--source-episode-id=epi_1",
+        "--source-episode-id=epi_2",
+        "--source-episode-id=epi_3",
+    ]))
+    .expect("repeated --source-episode-id must accumulate");
+    assert_eq!(
+        args.source_episode_ids,
+        vec![
+            "epi_1".to_string(),
+            "epi_2".to_string(),
+            "epi_3".to_string()
+        ]
+    );
+    // Confidence is optional — the server derives it regardless.
+    assert_eq!(args.confidence, None);
+}
+
+#[test]
+fn parse_reads_a_positional_state_root() {
+    let args = parse_remember_fact_args(argv(&[
+        "--concept=pr-pattern",
+        "--content=squash fixups before merge",
+        "--source-episode-id=epi_9",
+        "/tmp/some-state-root",
+    ]))
+    .expect("a positional state-root must parse");
+    assert_eq!(
+        args.state_root.as_deref(),
+        Some(std::path::Path::new("/tmp/some-state-root"))
+    );
+}
+
+#[test]
+fn parse_rejects_missing_concept() {
+    let err = parse_remember_fact_args(argv(&[
+        "--content=orphan content with no concept",
+        "--source-episode-id=epi_1",
+    ]))
+    .expect_err("a fact without --concept must be a usage error");
+    assert!(
+        err.contains("concept"),
+        "usage error must name the missing flag: {err}"
+    );
+}
+
+#[test]
+fn parse_rejects_missing_content() {
+    let err = parse_remember_fact_args(argv(&[
+        "--concept=bug-pattern",
+        "--source-episode-id=epi_1",
+    ]))
+    .expect_err("a fact without --content must be a usage error");
+    assert!(
+        err.contains("content"),
+        "usage error must name the missing flag: {err}"
+    );
+}
+
+#[test]
+fn parse_rejects_non_numeric_confidence() {
+    let err = parse_remember_fact_args(argv(&[
+        "--concept=bug-pattern",
+        "--content=three or more words here",
+        "--source-episode-id=epi_1",
+        "--confidence=not-a-number",
+    ]))
+    .expect_err("a non-numeric --confidence must be a usage error");
+    assert!(
+        err.contains("confidence"),
+        "usage error must name --confidence: {err}"
+    );
+}
+
+#[test]
+fn parse_rejects_unknown_flag() {
+    let err = parse_remember_fact_args(argv(&[
+        "--concept=bug-pattern",
+        "--content=three or more words here",
+        "--frobnicate=1",
+    ]))
+    .expect_err("an unknown flag must be a usage error");
+    assert!(
+        err.contains("frobnicate"),
+        "usage error must name the unknown flag: {err}"
+    );
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Exit codes
+// ───────────────────────────────────────────────────────────────────────────
+
+/// A usage error (missing required flag) exits 2 — distinct from a
+/// gate/transport failure so a mis-invoking agent is diagnosable.
+#[test]
+fn run_returns_exit_2_on_usage_error() {
+    let code = run_remember_fact(argv(&["--content=no concept given"]));
+    assert_eq!(code, 2, "missing --concept must exit 2 (usage), got {code}");
+}
+
+/// With a well-formed invocation but NO reachable daemon, the tool must exit 3
+/// rather than fall back to a direct (ungated) open. This is the "no bypass"
+/// invariant: the authoritative gate lives in the daemon, so no daemon means no
+/// gated write path.
+#[test]
+#[serial(cognitive_memory)]
+fn run_returns_exit_3_when_no_daemon_is_reachable() {
+    let _unset = EnvGuard::unset("SIMARD_MEMORY_SOCKET");
+    let tmp = tempfile::tempdir().expect("tempdir");
+    // No server was spawned in this TempDir, so <state_root>/memory.sock does
+    // not exist and connect must fail.
+    assert!(
+        !tmp.path().join("memory.sock").exists(),
+        "precondition: the hermetic state-root must have no live socket"
+    );
+
+    let code = run_remember_fact(argv(&[
+        "--concept=bug-pattern",
+        "--content=three or more words here",
+        "--source-episode-id=epi_1",
+        tmp.path().to_str().unwrap(),
+    ]));
+    assert_eq!(
+        code, 3,
+        "a well-formed remember with no reachable daemon must exit 3 (no ungated fallback), got {code}"
+    );
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Dispatch routing — `remember` is a recognized subcommand
+// ───────────────────────────────────────────────────────────────────────────
+
+/// `simard memory remember --help` must be recognized (print help, return Ok),
+/// proving the subcommand is routed and NOT rejected as an unsupported command.
+#[test]
+fn dispatch_recognizes_remember_help() {
+    let res = dispatch_memory_command(argv(&["remember", "--help"]).into_iter());
+    assert!(
+        res.is_ok(),
+        "`memory remember --help` must be a recognized, successful invocation"
+    );
+}
+
+/// An unknown subcommand is still rejected — the router must not have gone
+/// permissive.
+#[test]
+fn dispatch_still_rejects_unknown_subcommand() {
+    let err = dispatch_memory_command(argv(&["frobnicate"]).into_iter())
+        .expect_err("unknown subcommand must error")
+        .to_string();
+    assert!(err.contains("frobnicate"), "{err}");
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// Pass-id resolution — the distill runner tags the ledger via env, not a flag
+// (issue #2679 silent-metrics regression)
+// ───────────────────────────────────────────────────────────────────────────
+
+/// Precedence contract for [`resolve_pass_id`]: a non-empty explicit `--pass-id`
+/// wins; otherwise the `SIMARD_DISTILL_PASS_ID` env var (exported by the distill
+/// runner) is the fallback; empty/absent in both yields "" (no ledger tagging).
+#[test]
+#[serial(cognitive_memory)]
+fn resolve_pass_id_prefers_flag_then_env() {
+    let _guard = EnvGuard::unset("SIMARD_DISTILL_PASS_ID");
+
+    // Neither source set → empty (no ledger participation).
+    assert_eq!(resolve_pass_id(None), "");
+    assert_eq!(resolve_pass_id(Some("")), "");
+
+    // Explicit flag wins even when the env var is also set.
+    let _env = EnvGuard::set("SIMARD_DISTILL_PASS_ID", "from-env");
+    assert_eq!(resolve_pass_id(Some("from-flag")), "from-flag");
+
+    // No (usable) flag → fall back to the env var the runner exports.
+    assert_eq!(resolve_pass_id(None), "from-env");
+    assert_eq!(resolve_pass_id(Some("")), "from-env");
+}
+
+/// Real distill-path regression (issue #2679): the distiller agent runs
+/// `simard memory remember` with ONLY the content flags — the pass id reaches
+/// the CLI solely through the `SIMARD_DISTILL_PASS_ID` env var the runner
+/// exports. This drives the actual [`run_remember_fact`] entry point against a
+/// live gate and proves the env-var fallback tags the server's per-pass ledger,
+/// so `drain_pass_ledger` returns the real accepted-fact count on production.
+///
+/// Before the fallback, `run_remember_fact` resolved an EMPTY pass id here, the
+/// server's `ledger_record_stored` no-op'd it, and the drain returned 0 — the
+/// silent-degradation bug that made every distill pass report `fact_count = 0` /
+/// `reduction_pct = 100%` while facts were actually stored. Every prior test
+/// passed `--pass-id` explicitly, so none exercised this production path.
+#[test]
+#[serial(cognitive_memory)]
+fn remember_without_flag_tags_ledger_from_env_pass_id() {
+    use std::sync::Arc;
+    use std::time::Duration;
+
+    use crate::cognitive_memory::{CognitiveMemoryOps, LibraryCognitiveMemory};
+    use crate::memory_ipc::{RemoteCognitiveMemory, spawn_server};
+
+    let dir = tempfile::tempdir().expect("tempdir");
+    let sock = dir.path().join("memory.sock");
+    let mem: Arc<dyn CognitiveMemoryOps> =
+        Arc::new(LibraryCognitiveMemory::in_memory().expect("in-memory db"));
+
+    // Seed a real episode so the cited fact is grounded and the gate accepts it.
+    let episode_id = mem
+        .store_episode(
+            "empty outcome list panicked the cycle",
+            "engineer-cycle",
+            None,
+        )
+        .expect("store_episode");
+
+    let _handle = spawn_server(sock.clone(), Arc::clone(&mem)).expect("spawn server");
+    for _ in 0..50 {
+        if sock.exists() {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(20));
+    }
+    assert!(sock.exists(), "server socket must come up");
+
+    // Point the CLI at THIS server and supply the pass id ONLY via the env var
+    // the distill runner exports — exactly the production invocation shape.
+    let pass_id = format!("env-path-{}", std::process::id());
+    let _sock_env = EnvGuard::set("SIMARD_MEMORY_SOCKET", sock.to_str().unwrap());
+    let _pass_env = EnvGuard::set("SIMARD_DISTILL_PASS_ID", &pass_id);
+
+    // NOTE: no `--pass-id` flag — the recipe never tells the agent to pass one.
+    let code = run_remember_fact(argv(&[
+        "--concept=bug-pattern",
+        "--content=empty outcome list panics cycle",
+        &format!("--source-episode-id={episode_id}"),
+    ]));
+    assert_eq!(
+        code, 0,
+        "a grounded fact against a reachable daemon must store (exit 0), got {code}"
+    );
+
+    // The env-var pass id must have tagged the ledger; a 0 here is the #2679
+    // silent-metrics regression (facts stored but the pass reports none).
+    let client = RemoteCognitiveMemory::connect(&sock).expect("connect");
+    assert_eq!(
+        client.drain_pass_ledger(&pass_id).expect("drain"),
+        1,
+        "the env-var pass id must tag the write ledger even with no --pass-id flag"
+    );
+}
diff --git a/tests/bin_simard_memory_remember_cli.rs b/tests/bin_simard_memory_remember_cli.rs
new file mode 100644
index 00000000..7934eba4
--- /dev/null
+++ b/tests/bin_simard_memory_remember_cli.rs
@@ -0,0 +1,270 @@
+//! Process-boundary integration tests for the distiller's WRITE tools
+//! `simard memory remember` / `simard memory remember-procedure` (issue #2679).
+//!
+//! These exercise the *external-service integration* that neither the
+//! `operator_cli::memory` unit tests nor the in-crate `memory_ipc` gated-write
+//! tests can: the **real `simard` binary**, spawned as a separate process,
+//! reaching a **live memory IPC socket** and committing a fact through the
+//! server-side write-boundary gate. This is the exact path the distiller agent
+//! drives during a semantic-handoff pass — `SIMARD_MEMORY_SOCKET` is exported to
+//! the agent, and every fact becomes one `simard memory remember` process.
+//!
+//! The whole point of #2679 is that the agent's writes ARE its output: there is
+//! no `{ "facts": [...] }` document scraped back out of noisy stdout and
+//! hand-deserialized. These tests pin that the binary honours the documented
+//! exit-code contract (0 stored / 2 usage / 3 no daemon / 4 quarantined) against
+//! a real gate, and that a grounded fact genuinely lands in semantic memory.
+
+use std::sync::Arc;
+use std::time::Duration;
+
+use assert_cmd::Command;
+use simard::cognitive_memory::{CognitiveMemoryOps, LibraryCognitiveMemory};
+use simard::memory_ipc::{RemoteCognitiveMemory, spawn_server};
+use tempfile::TempDir;
+
+/// A live in-memory cognitive store fronted by a real IPC server on a unix
+/// socket. Holds the `TempDir` and `ServerHandle` alive for the test's lifetime.
+struct LiveDaemon {
+    _dir: TempDir,
+    sock: std::path::PathBuf,
+    mem: Arc<dyn CognitiveMemoryOps>,
+    _handle: simard::memory_ipc::ServerHandle,
+}
+
+impl LiveDaemon {
+    /// Spawn a real server over a fresh in-memory backend and block until the
+    /// socket is accepting connections.
+    fn start() -> Self {
+        let dir = tempfile::tempdir().expect("tempdir");
+        let sock = dir.path().join("memory.sock");
+        let mem: Arc<dyn CognitiveMemoryOps> =
+            Arc::new(LibraryCognitiveMemory::in_memory().expect("in-memory db"));
+        let handle = spawn_server(sock.clone(), Arc::clone(&mem)).expect("spawn server");
+        for _ in 0..100 {
+            if sock.exists() {
+                break;
+            }
+            std::thread::sleep(Duration::from_millis(20));
+        }
+        assert!(sock.exists(), "server socket never appeared at {sock:?}");
+        Self {
+            _dir: dir,
+            sock,
+            mem,
+            _handle: handle,
+        }
+    }
+
+    /// Seed a real episode so a fact citing its id is *grounded* by the gate's
+    /// store-existence check. Returns the episode node id.
+    fn seed_episode(&self, content: &str) -> String {
+        self.mem
+            .store_episode(content, "engineer-cycle", None)
+            .expect("store_episode")
+    }
+
+    /// `simard memory remember ...` pinned to this daemon's socket, hermetic
+    /// (no update check, no leaked state root). Mirrors how the subprocess
+    /// distiller runner exports `SIMARD_MEMORY_SOCKET` to the agent.
+    fn remember(&self, args: &[&str]) -> std::process::Output {
+        let mut cmd = Command::cargo_bin("simard").expect("simard must build");
+        cmd.env("SIMARD_NO_UPDATE_CHECK", "1")
+            .env("SIMARD_MEMORY_SOCKET", &self.sock)
+            .env_remove("SIMARD_STATE_ROOT")
+            .arg("memory");
+        cmd.args(args);
+        cmd.output().expect("run simard memory remember")
+    }
+
+    /// A fresh client connection for read-back verification through the gate.
+    fn client(&self) -> RemoteCognitiveMemory {
+        RemoteCognitiveMemory::connect(&self.sock).expect("connect")
+    }
+}
+
+fn code(out: &std::process::Output) -> i32 {
+    out.status
+        .code()
+        .expect("process exited via signal, not code")
+}
+
+/// The headline external-service path: a grounded, well-formed fact written by
+/// the *real binary* clears the gate (exit 0) and is genuinely retrievable from
+/// semantic memory — no document ever parsed anywhere in the path.
+#[test]
+fn remember_cli_stores_grounded_fact_end_to_end() {
+    let daemon = LiveDaemon::start();
+    let episode_id = daemon.seed_episode("empty outcome list panicked the cycle");
+
+    let out = daemon.remember(&[
+        "remember",
+        "--concept",
+        "bug-pattern",
+        "--content",
+        "empty outcome list panics cycle",
+        "--source-episode-id",
+        &episode_id,
+        "--pass-id",
+        "pass-live-1",
+    ]);
+
+    assert_eq!(
+        code(&out),
+        0,
+        "grounded fact must exit 0 (stored); stderr={}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("stored concept=bug-pattern"),
+        "stdout must confirm the store; got {stdout:?}"
+    );
+
+    // Prove the write really reached semantic memory through the gate.
+    let facts = daemon
+        .client()
+        .search_facts("bug-pattern", 10, 0.0)
+        .expect("search_facts");
+    assert!(
+        facts
+            .iter()
+            .any(|f| f.content == "empty outcome list panics cycle"),
+        "the committed fact must be present in semantic memory; got {facts:?}"
+    );
+}
+
+/// A fact citing an episode id that does not exist is ungrounded: the server
+/// gate quarantines it (exit 4) and nothing leaks into semantic memory. This is
+/// the anti-hallucination guarantee, enforced at the process boundary.
+#[test]
+fn remember_cli_quarantines_ungrounded_fact() {
+    let daemon = LiveDaemon::start();
+
+    let out = daemon.remember(&[
+        "remember",
+        "--concept",
+        "bug-pattern",
+        "--content",
+        "three or more words here",
+        "--source-episode-id",
+        "epi_does_not_exist",
+        "--pass-id",
+        "pass-live-2",
+    ]);
+
+    assert_eq!(
+        code(&out),
+        4,
+        "ungrounded fact must exit 4 (quarantined); stdout={} stderr={}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert!(
+        String::from_utf8_lossy(&out.stderr).contains("quarantined"),
+        "stderr must explain the quarantine"
+    );
+
+    let facts = daemon
+        .client()
+        .search_facts("bug-pattern", 10, 0.0)
+        .expect("search_facts");
+    assert!(
+        facts.is_empty(),
+        "no ungrounded fact may leak into semantic memory; got {facts:?}"
+    );
+}
+
+/// With no reachable daemon there is deliberately NO un-gated on-disk fallback
+/// (a direct open would bypass the authoritative gate), so the binary exits 3.
+#[test]
+fn remember_cli_no_daemon_exits_3() {
+    let dir = tempfile::tempdir().expect("tempdir");
+    let dead_sock = dir.path().join("nonexistent.sock");
+
+    let out = Command::cargo_bin("simard")
+        .expect("simard must build")
+        .env("SIMARD_NO_UPDATE_CHECK", "1")
+        .env("SIMARD_MEMORY_SOCKET", &dead_sock)
+        .env_remove("SIMARD_STATE_ROOT")
+        .args([
+            "memory",
+            "remember",
+            "--concept",
+            "bug-pattern",
+            "--content",
+            "no daemon is listening here",
+        ])
+        .output()
+        .expect("run simard memory remember");
+
+    assert_eq!(
+        code(&out),
+        3,
+        "missing daemon must exit 3 (no reachable daemon); stderr={}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert!(
+        String::from_utf8_lossy(&out.stderr).contains("no reachable memory daemon"),
+        "stderr must name the missing daemon"
+    );
+}
+
+/// A malformed invocation (required `--content` missing) is a usage error (exit
+/// 2) and never reaches the daemon — parsing fails first.
+#[test]
+fn remember_cli_missing_required_flag_exits_2() {
+    let out = Command::cargo_bin("simard")
+        .expect("simard must build")
+        .env("SIMARD_NO_UPDATE_CHECK", "1")
+        .env_remove("SIMARD_STATE_ROOT")
+        .args(["memory", "remember", "--concept", "bug-pattern"])
+        .output()
+        .expect("run simard memory remember");
+
+    assert_eq!(
+        code(&out),
+        2,
+        "missing --content must exit 2 (usage error); stderr={}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert!(
+        String::from_utf8_lossy(&out.stderr).contains("missing required --content"),
+        "stderr must name the missing flag"
+    );
+}
+
+/// The companion procedure write tool commits through the same live socket and
+/// returns a node id (exit 0) — the recurring-procedure half of the handoff.
+#[test]
+fn remember_procedure_cli_stores_end_to_end() {
+    let daemon = LiveDaemon::start();
+    let episode_id = daemon.seed_episode("fixed the bug by reading then editing then testing");
+
+    let out = daemon.remember(&[
+        "remember-procedure",
+        "--name",
+        "fix-and-verify",
+        "--step",
+        "read the failing file",
+        "--step",
+        "edit the offending code",
+        "--step",
+        "run cargo test",
+        "--source-episode-id",
+        &episode_id,
+        "--pass-id",
+        "pass-live-3",
+    ]);
+
+    assert_eq!(
+        code(&out),
+        0,
+        "procedure write must exit 0 (stored); stderr={}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    assert!(
+        String::from_utf8_lossy(&out.stdout).contains("stored name=fix-and-verify"),
+        "stdout must confirm the procedure store"
+    );
+}
diff --git a/tests/gadugi/distill-fact-yield.yaml b/tests/gadugi/distill-fact-yield.yaml
deleted file mode 100644
index 5bf09acf..00000000
--- a/tests/gadugi/distill-fact-yield.yaml
+++ /dev/null
@@ -1,112 +0,0 @@
-name: "Distillation Fact-Yield Canonicalization"
-description: >
-  qa-team outside-in gate for the perpetual-cognition sub-goal "raise
-  distillation fact-yield". Simard's episode distiller
-  (src/memory_consolidation/distillation.rs) previously dropped a candidate
-  fact whenever the LLM emitted a concept label in any surface form other than
-  the exact lower-hyphen string — title/upper case (PR-Pattern, BUG-PATTERN),
-  surrounding whitespace/quotes/punctuation (" bug-pattern ", pr-pattern.), or
-  underscore/space separators (pr_pattern, lesson learned). Those well-formed,
-  grounded facts were lost purely to cosmetics, depressing fact-yield. The
-  concept filter now canonicalizes surface-form variants back to the fixed
-  label set before the closed-set match, recovering the facts WITHOUT weakening
-  precision: genuinely off-spec labels are still dropped and the reliability
-  gate still quarantines ungrounded/empty facts. A deterministic fixed-corpus
-  benchmark records the before/after numbers (baseline promoted=3 yield=0.120 →
-  improved promoted=8 yield=0.320, precision held at 1.000) so a regression
-  fails CI. This scenario pins that behaviour end-to-end.
-version: "1.0.0"
-
-config:
-  timeout: 900000
-  retries: 1
-  parallel: false
-
-environment:
-  requires: []
-
-agents:
-  - name: "test-agent"
-    type: "cli"
-    config:
-      workingDirectory: "."
-      defaultTimeout: 900000
-      executionMode: "spawn"
-      captureOutput: true
-      ioConfig:
-        encoding: "utf8"
-        handleInteractivePrompts: false
-      logConfig:
-        logCommands: true
-        logOutput: true
-        logLevel: "info"
-
-steps:
-  - name: "Fact-yield benchmark records baseline and proves precision-safe improvement"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib
-        memory_consolidation::distillation_fact_yield_bench
-        -- --nocapture
-    timeout: 900000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "baseline_promoted=3 improved_promoted=8"
-        - "baseline_yield=0.120 improved_yield=0.320"
-        - "improved_structural_precision=1.000"
-        - "fact_yield_benchmark_records_baseline_and_proves_improvement ... ok"
-        - "fact_yield_benchmark_recovers_only_surface_variants_not_offspec ... ok"
-        - "test result: ok"
-
-  - name: "Concept canonicalization recovers surface variants but rejects off-spec (precision guard)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib
-        memory_consolidation::distillation::unit_tests
-        -- --nocapture
-    timeout: 900000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "canonical_concept_accepts_surface_form_variants ... ok"
-        - "canonical_concept_rejects_offspec_labels ... ok"
-        - "into_facts_recovers_surface_variant_but_drops_offspec ... ok"
-        - "test result: ok"
-
-  - name: "Full distillation parser + reliability-gate + dedup contract still green (no regression)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib memory_consolidation::distillation
-        -- --nocapture
-    timeout: 900000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "parse_recipe_output_drops_unknown_concepts ... ok"
-        - "full_pass_promotes_canonicalized_surface_variants_through_dedup ... ok"
-        - "test result: ok"
-
-assertions: []
-
-cleanup:
-  - name: "CLI agent cleanup"
-    agent: "test-agent"
-    action: "cleanup"
-
-metadata:
-  tags:
-    - "cli"
-    - "memory"
-    - "distillation"
-    - "fact-yield"
-    - "regression"
-  priority: "high"
-  author: "copilot"
-  test_type: "outside-in"
diff --git a/tests/gadugi/distill-parser-copilot-launch-log.yaml b/tests/gadugi/distill-parser-copilot-launch-log.yaml
deleted file mode 100644
index 7f307d2d..00000000
--- a/tests/gadugi/distill-parser-copilot-launch-log.yaml
+++ /dev/null
@@ -1,84 +0,0 @@
-name: "Distill Parser Tolerates Copilot Launch-Log Preamble"
-description: >
-  Outside-in regression gate for issue #2496 (episode t=9271 live failure).
-  The episode->fact distillation parser must recover the { "facts": [...] }
-  object from the Tier-1 recipe-runner `--output-format json` envelope even
-  when the distill step output is the noisy Copilot CLI launch preamble:
-  an ANSI-coloured `launching copilot` line, a NODE_OPTIONS line, and a
-  leading ANSI-wrapped JSON log record ({"level":"info",...}) ahead of the
-  real facts object. The current parser (issues #2401/#2461/#2484) already
-  strips ANSI/log noise and prefers the last non-empty facts object; this
-  scenario pins the captured launch-log shape end-to-end so it cannot
-  regress.
-version: "1.0.0"
-
-config:
-  timeout: 600000
-  retries: 1
-  parallel: false
-
-environment:
-  requires: []
-
-agents:
-  - name: "test-agent"
-    type: "cli"
-    config:
-      workingDirectory: "."
-      defaultTimeout: 600000
-      executionMode: "spawn"
-      captureOutput: true
-      ioConfig:
-        encoding: "utf8"
-        handleInteractivePrompts: false
-      logConfig:
-        logCommands: true
-        logOutput: true
-        logLevel: "info"
-
-steps:
-  - name: "Distill parser recovers facts from Copilot launch-log preamble (#2496)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib
-        parse_recipe_output_full_recovers_facts_from_copilot_launch_log_preamble
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "parse_recipe_output_full_recovers_facts_from_copilot_launch_log_preamble ... ok"
-        - "test result: ok"
-
-  - name: "Full distillation parser contract still green (no regression)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib memory_consolidation::distillation::unit_tests
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "test result: ok"
-
-assertions: []
-
-cleanup:
-  - name: "CLI agent cleanup"
-    agent: "test-agent"
-    action: "cleanup"
-
-metadata:
-  tags:
-    - "cli"
-    - "memory"
-    - "distillation"
-    - "regression"
-    - "issue-2496"
-  priority: "high"
-  author: "copilot"
-  test_type: "outside-in"
diff --git a/tests/gadugi/distill-parser-field-tolerance.yaml b/tests/gadugi/distill-parser-field-tolerance.yaml
deleted file mode 100644
index 94e12863..00000000
--- a/tests/gadugi/distill-parser-field-tolerance.yaml
+++ /dev/null
@@ -1,106 +0,0 @@
-name: "Distill Parser Tolerates Field-Incomplete Facts"
-description: >
-  Outside-in regression gate for episode t=9664 (live OODA consolidation,
-  2026-06-30, Copilot CLI 1.0.66-2). The episode->fact distillation bridge kept
-  failing every cycle with `distill: `distill` step output did not contain a
-  parseable { "facts": [...] } object` EVEN THOUGH all ANSI/launch-log preamble
-  shapes were already stripped (#2479/#2484/#2490/#2496/#2504). The residual
-  root cause was field-level strictness: the agent intermittently omits / nulls
-  / scalar-types a single `facts[]` field (most often `source_episode_id`),
-  which made serde reject the WHOLE envelope so the entire batch was silently
-  dropped and re-deferred forever. The parser now deserializes fact fields
-  leniently (de_lenient_string): one malformed fact no longer sinks its
-  well-formed siblings, and an ungrounded recovered fact is still quarantined by
-  the reliability gate rather than promoted blindly. This scenario pins that
-  behaviour end-to-end so it cannot regress.
-version: "1.0.0"
-
-config:
-  timeout: 600000
-  retries: 1
-  parallel: false
-
-environment:
-  requires: []
-
-agents:
-  - name: "test-agent"
-    type: "cli"
-    config:
-      workingDirectory: "."
-      defaultTimeout: 600000
-      executionMode: "spawn"
-      captureOutput: true
-      ioConfig:
-        encoding: "utf8"
-        handleInteractivePrompts: false
-      logConfig:
-        logCommands: true
-        logOutput: true
-        logLevel: "info"
-
-steps:
-  - name: "Well-formed fact survives a field-incomplete sibling behind launch-log noise (t=9664)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib
-        issue_t9664_field_tolerance_tests
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "distill_recovers_wellformed_fact_when_sibling_omits_source_episode_id ... ok"
-        - "parse_recipe_output_tolerates_fact_missing_source_episode_id ... ok"
-        - "parse_recipe_output_tolerates_null_and_scalar_fields ... ok"
-        - "recovered_fact_with_missing_provenance_is_still_quarantined_by_the_gate ... ok"
-        - "grounded_object_wins_over_trailing_sourceless_object ... ok"
-        - "non_scalar_field_values_collapse_to_empty ... ok"
-        - "test result: ok"
-
-  - name: "Launch-log preamble regression (#2496) still green (no regression)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib
-        parse_recipe_output_full_recovers_facts_from_copilot_launch_log_preamble
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "test result: ok"
-
-  - name: "Full distillation parser contract still green (no regression)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib memory_consolidation::distillation
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "test result: ok"
-
-assertions: []
-
-cleanup:
-  - name: "CLI agent cleanup"
-    agent: "test-agent"
-    action: "cleanup"
-
-metadata:
-  tags:
-    - "cli"
-    - "memory"
-    - "distillation"
-    - "regression"
-    - "issue-t9664"
-  priority: "high"
-  author: "copilot"
-  test_type: "outside-in"
diff --git a/tests/gadugi/distill-parser-launch-banner-pretty-envelope.yaml b/tests/gadugi/distill-parser-launch-banner-pretty-envelope.yaml
deleted file mode 100644
index 27705531..00000000
--- a/tests/gadugi/distill-parser-launch-banner-pretty-envelope.yaml
+++ /dev/null
@@ -1,107 +0,0 @@
-name: "Distill Parser Recovers Facts AND Procedures From a Pretty Envelope Behind the Launch Banner"
-description: >
-  Outside-in regression gate for issue #2517 — the high-fidelity successor to
-  the #2512 outer-envelope banner fix. In production recipe-runner-rs
-  `--output-format json` emits a PRETTY-printed envelope (see
-  `REAL_RUNNER_ENVELOPE_VERBATIM`), and the distill agent subprocess prints its
-  own GitHub Copilot CLI `1.0.66-2` launch banner into the captured stdout that
-  becomes the escaped `output` string of the `distill` step. The stdout also
-  BEGINS WITH the outer launch banner (#2512), forcing Tier-1b recovery. There,
-  the line-dropping `strip_recipe_noise` view drops the whole
-  `"output": "...launching copilot binary=..."` line, leaving a
-  structurally-valid but GUTTED envelope (`output` → null). The old first-match
-  recovery committed to that gutted envelope, `extract_step_output` returned
-  None, and the batch's facts AND procedures were silently swallowed with the
-  recurring `distill failed (non-fatal): ... did not yield a parseable
-  { "facts": [...] }` error — the #2512 compact-envelope test did not catch it
-  because a compact one-line envelope is dropped wholesale and falls through to
-  the line-preserving view.
-
-  The fix (`recover_distill_output` + `candidate_runner_envelopes`) evaluates
-  BOTH cleaned views and commits to the candidate that actually yields a
-  populated `DistillOutput`, so the intact `strip_ansi` view wins over the
-  gutted `strip_recipe_noise` view. (Post-#2570: the shared structural-token
-  guard now preserves that `"output": …` line, so the line-dropping view
-  recovers this pretty shape on its own; the two-view selection remains as
-  defence-in-depth for shapes it can still gut.) This scenario pins the full
-  ANSI-wrapped multi-line `1.0.66-2` banner + pretty envelope + inner-banner
-  `output` shape end-to-end (facts AND procedures recovered), preserves the
-  `success == false` -> RecipeReportedFailure contract, and keeps a genuinely
-  empty "nothing to distill" answer an empty Ok (no burned retry) so the
-  `distill_parse_success_rate` metric path stays green.
-version: "1.0.0"
-
-config:
-  timeout: 600000
-  retries: 1
-  parallel: false
-
-environment:
-  requires: []
-
-agents:
-  - name: "test-agent"
-    type: "cli"
-    config:
-      workingDirectory: "."
-      defaultTimeout: 600000
-      executionMode: "spawn"
-      captureOutput: true
-      ioConfig:
-        encoding: "utf8"
-        handleInteractivePrompts: false
-      logConfig:
-        logCommands: true
-        logOutput: true
-        logLevel: "info"
-
-steps:
-  - name: "Distill parser recovers facts AND procedures from a pretty envelope behind the launch banner (#2517)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib
-        issue_2517_pretty_envelope_launch_banner_tests
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "full_1_0_66_2_launch_banner_with_ansi_and_envelope_recovers_facts_and_procedures ... ok"
-        - "facts_only_wrapper_recovers_facts_from_pretty_envelope ... ok"
-        - "line_dropping_view_preserves_pretty_envelope_output_after_2570_guard ... ok"
-        - "banner_prefixed_failed_pretty_envelope_reports_recipe_failure ... ok"
-        - "banner_prefixed_pretty_envelope_with_nothing_to_distill_returns_empty_ok ... ok"
-        - "test result: ok"
-
-  - name: "Full distillation parser contract still green (no regression)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib memory_consolidation::distillation
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "test result: ok"
-
-assertions: []
-
-cleanup:
-  - name: "CLI agent cleanup"
-    agent: "test-agent"
-    action: "cleanup"
-
-metadata:
-  tags:
-    - "cli"
-    - "memory"
-    - "distillation"
-    - "regression"
-    - "issue-2517"
-  priority: "high"
-  author: "copilot"
-  test_type: "outside-in"
diff --git a/tests/gadugi/distill-parser-outer-envelope-banner.yaml b/tests/gadugi/distill-parser-outer-envelope-banner.yaml
deleted file mode 100644
index 635e9318..00000000
--- a/tests/gadugi/distill-parser-outer-envelope-banner.yaml
+++ /dev/null
@@ -1,90 +0,0 @@
-name: "Distill Parser Recovers Facts When Launch Banner Precedes the Envelope"
-description: >
-  Outside-in regression gate for issue #2512 — the distill-side analog of the
-  #2504 decide/orient launch-banner fix. The Copilot CLI subprocess prints its
-  launch preamble (the `NODE_OPTIONS` (saved preference) marker, the
-  `launching copilot binary=... version="GitHub Copilot CLI ..."` line, and the
-  `Run 'copilot update'...` nag) and intermittent ANSI tracing lines to the
-  inherited stdout BEFORE recipe-runner-rs emits its `--output-format json`
-  envelope. The captured stdout therefore BEGINS WITH the banner instead of the
-  `{` of the envelope, so the fast Tier-1a `serde_json` envelope parse rejected
-  it and the whole 20-episode batch silently deferred with
-  `distill failed (non-fatal): ... did not yield a parseable { "facts": [...] }`.
-  Tier-1b (`recover_runner_envelope`) now recovers the envelope through the same
-  shared `recipe_output` chokepoint, so a banner-prefixed envelope still yields
-  non-empty facts. This scenario pins the outer-envelope banner shapes
-  end-to-end so they cannot regress, and confirms the first-class
-  `distill_parse_success_rate` metric path stays green.
-version: "1.0.0"
-
-config:
-  timeout: 600000
-  retries: 1
-  parallel: false
-
-environment:
-  requires: []
-
-agents:
-  - name: "test-agent"
-    type: "cli"
-    config:
-      workingDirectory: "."
-      defaultTimeout: 600000
-      executionMode: "spawn"
-      captureOutput: true
-      ioConfig:
-        encoding: "utf8"
-        handleInteractivePrompts: false
-      logConfig:
-        logCommands: true
-        logOutput: true
-        logLevel: "info"
-
-steps:
-  - name: "Distill parser recovers facts when the launch banner precedes the envelope (#2512)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib
-        issue_2512_outer_envelope_banner_tests
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "recovers_facts_when_bare_launch_banner_precedes_envelope ... ok"
-        - "banner_prefixed_failed_envelope_reports_recipe_failure_not_silent_drop ... ok"
-        - "test result: ok"
-
-  - name: "Full distillation parser contract still green (no regression)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib memory_consolidation::distillation
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "test result: ok"
-
-assertions: []
-
-cleanup:
-  - name: "CLI agent cleanup"
-    agent: "test-agent"
-    action: "cleanup"
-
-metadata:
-  tags:
-    - "cli"
-    - "memory"
-    - "distillation"
-    - "regression"
-    - "issue-2512"
-  priority: "high"
-  author: "copilot"
-  test_type: "outside-in"
diff --git a/tests/gadugi/distill-parser-unbalanced-brace-prose.yaml b/tests/gadugi/distill-parser-unbalanced-brace-prose.yaml
deleted file mode 100644
index 59c49d10..00000000
--- a/tests/gadugi/distill-parser-unbalanced-brace-prose.yaml
+++ /dev/null
@@ -1,118 +0,0 @@
-name: "Distill Parser Recovers Answer After an Unmatched Brace in Prose"
-description: >
-  Outside-in regression gate for issue #2508 (residual of the t=9900 live
-  consolidation no-op). The episode->fact distillation parser must recover the
-  { "facts": [...] } object even when the distill agent's leading prose carries
-  an UNMATCHED `{` ahead of its JSON answer. This is realistic because the
-  distiller reasons about CODE episodes and intermittently writes a fragment
-  like `fn handler() {` in its preamble. The distillation scanner previously
-  used a hand-rolled single-shared-depth scan, so a stray unmatched `{` raised
-  depth permanently and demoted the real answer to a nested span that was never
-  recorded as top-level -> the pass found no facts object and silently no-opped
-  (zero facts). The fix reuses the shared, string-aware
-  `recipe_output::balanced_objects` helper (candidate-restart past an unmatched
-  `{`). The launch-banner / unmatched-QUOTE cases were already fixed
-  (#2461/#2496/#2504/#2506); this scenario pins the unmatched-BRACE case so it
-  cannot regress, while asserting that genuinely answer-less output still fails
-  non-fatally (Err) without panicking.
-version: "1.0.0"
-
-config:
-  timeout: 600000
-  retries: 1
-  parallel: false
-
-environment:
-  requires: []
-
-agents:
-  - name: "test-agent"
-    type: "cli"
-    config:
-      workingDirectory: "."
-      defaultTimeout: 600000
-      executionMode: "spawn"
-      captureOutput: true
-      ioConfig:
-        encoding: "utf8"
-        handleInteractivePrompts: false
-      logConfig:
-        logCommands: true
-        logOutput: true
-        logLevel: "info"
-
-steps:
-  - name: "Shared scanner skips an unmatched leading `{` and recovers the object (#2508)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib
-        recipe_output::extract::tests::balanced_objects_skips_unmatched_leading_brace
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "balanced_objects_skips_unmatched_leading_brace ... ok"
-        - "test result: ok"
-
-  - name: "Distillation recovers the answer after an unmatched `{`; answer-less output stays non-fatal (#2508)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib memory_consolidation::distillation::unit_tests
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "parse_recipe_output_recovers_from_unbalanced_brace_in_leading_prose ... ok"
-        - "parse_recipe_output_banner_only_fails_non_fatally_without_panic ... ok"
-        - "test result: ok"
-
-  - name: "Launch-log preamble regression (#2496) still green (no regression)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib
-        parse_recipe_output_full_recovers_facts_from_copilot_launch_log_preamble
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "test result: ok"
-
-  - name: "Full distillation parser contract still green (no regression)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib memory_consolidation::distillation
-        -- --nocapture
-    timeout: 600000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "test result: ok"
-
-assertions: []
-
-cleanup:
-  - name: "CLI agent cleanup"
-    agent: "test-agent"
-    action: "cleanup"
-
-metadata:
-  tags:
-    - "cli"
-    - "memory"
-    - "distillation"
-    - "regression"
-    - "issue-2508"
-  priority: "high"
-  author: "copilot"
-  test_type: "outside-in"
diff --git a/tests/gadugi/distill-reliability.yaml b/tests/gadugi/distill-reliability.yaml
deleted file mode 100644
index 883fd969..00000000
--- a/tests/gadugi/distill-reliability.yaml
+++ /dev/null
@@ -1,104 +0,0 @@
-name: "Brain reliability — distill parsing & distill_success_rate"
-description: >
-  Outside-in gate for issue #2461 (distill recipe failing non-fatally during
-  consolidation, silently swallowed). Two regressions are pinned: (1) the
-  tolerant parser now returns the *last* balanced facts object so a leading
-  recipe banner no longer shadows the agent's answer (the t=7517 parse-failure
-  mode), with string-aware brace scanning; and (2) every pass that runs the
-  recipe records a `distill_success_rate` metric (value 1.0 on success / 0.0 on
-  failure) whose context classifies the failure mode, so the previously-silent
-  non-fatal failures become measurable from metrics.jsonl. Backing tests live in
-  `src/memory_consolidation/distillation.rs` (unit_tests).
-version: "1.0.0"
-
-config:
-  timeout: 300000
-  retries: 1
-  parallel: false
-
-environment:
-  requires: []
-
-agents:
-  - name: "test-agent"
-    type: "cli"
-    config:
-      workingDirectory: "."
-      defaultTimeout: 300000
-      executionMode: "spawn"
-      captureOutput: true
-      ioConfig:
-        encoding: "utf8"
-        handleInteractivePrompts: false
-      logConfig:
-        logCommands: true
-        logOutput: true
-        logLevel: "info"
-
-steps:
-  - name: "#2461 — last-object-wins + string-aware parsing (banner no longer shadows facts)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib memory_consolidation::distillation::unit_tests::parse_recipe_output
-        -- --nocapture --test-threads=1
-    timeout: 300000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "parse_recipe_output_prefers_last_facts_object_over_leading_banner ... ok"
-        - "parse_recipe_output_tolerates_braces_inside_fact_content ... ok"
-        - "parse_recipe_output_handles_unmatched_quote_in_leading_prose ... ok"
-        - "test result: ok."
-
-  - name: "#2461 — failure classification anchors on prefix (terminal vs parse)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib memory_consolidation::distillation::unit_tests::classify
-        -- --nocapture --test-threads=1
-    timeout: 300000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "classify_distill_error_buckets_each_failure_mode ... ok"
-        - "classify_anchors_on_prefix_not_embedded_stdout ... ok"
-        - "test result: ok."
-
-  - name: "#2461 — distill_success_rate metric context (success / parse-failure / terminal-failure)"
-    agent: "test-agent"
-    action: "execute_command"
-    params:
-      command: >
-        cargo test --lib memory_consolidation::distillation::unit_tests::
-        -- --nocapture --test-threads=1
-    timeout: 300000
-    expect:
-      exitCode: 0
-      outputContains:
-        - "success_metric_context_marks_parse_attempted_and_parse_success ... ok"
-        - "parse_failure_metric_context_attempted_parsing_but_failed ... ok"
-        - "terminal_failure_metric_context_did_not_reach_parsing ... ok"
-        - "test result: ok."
-
-assertions: []
-
-cleanup:
-  - name: "Test agent cleanup"
-    agent: "test-agent"
-    action: "cleanup"
-
-metadata:
-  tags:
-    - "cli"
-    - "cognitive-memory"
-    - "distillation"
-    - "brain-reliability"
-    - "metrics"
-    - "regression"
-    - "issue-2461"
-  priority: "high"
-  author: "copilot"
-  test_type: "outside-in"
diff --git a/tests/gadugi/distill-semantic-handoff.yaml b/tests/gadugi/distill-semantic-handoff.yaml
new file mode 100644
index 00000000..742fc7a8
--- /dev/null
+++ b/tests/gadugi/distill-semantic-handoff.yaml
@@ -0,0 +1,134 @@
+name: distill-semantic-handoff
+app_type: cli
+description: |
+  Outside-in proof that episode->fact distillation no longer relies on parsing
+  (issue #2679, root cause shared with #2658). The distiller is now a true
+  agentic step whose WRITES are its output: it commits each fact through the
+  cognitive-memory write boundary (`simard memory remember` -> IPC
+  `StoreFactGated`), so there is NO `{ "facts": [...] }` document scraped back out
+  of noisy recipe stdout and hand-deserialized. The trailing-comma / launcher-
+  banner / ANSI parse-failure mode that discarded whole batches is therefore
+  STRUCTURALLY IMPOSSIBLE — there is nothing left to parse.
+
+  This scenario replaces the retired `distill-parser-*` / `distill-fact-yield` /
+  `distill-trailing-comma-parse` scenarios (which validated the removed parse).
+  It drives the hermetic in-process unit tests that pin the new contract: the
+  result path is an exit-status check that ignores stdout (noisy/trailing-comma
+  stdout can no longer fail the pipeline), the shared per-fact reliability scorer,
+  the server-side write-boundary gate (ground/score/quarantine/dedup), and the
+  agent-facing `simard memory remember` write tool. No network, no live host
+  mutation. The CLI runner rejects any non-zero exit.
+agents:
+  - name: simard-cli
+    type: cli
+    command: cargo
+
+steps:
+  # Headline (#2679/#2658): a finished recipe run is interpreted by EXIT STATUS
+  # alone — noisy / trailing-comma / banner-polluted stdout is never parsed, so
+  # it can no longer fail the pipeline. Plus the agentic pass commits grounded
+  # facts and quarantines ungrounded/empty ones through the in-process sink.
+  - action: run
+    params:
+      command: "cargo test --locked --lib memory_consolidation::distillation_semantic_handoff_tests"
+    timeout: 600000
+  - action: wait_for_output
+    params:
+      value: "test result: ok"
+    timeout: 8000
+  - action: validate_exit_code
+    params:
+      value: "0"
+    timeout: 5000
+
+  # The shared per-fact reliability scorer both write-boundary seams use.
+  - action: run
+    params:
+      command: "cargo test --locked --lib fact_reliability_tests"
+    timeout: 600000
+  - action: wait_for_output
+    params:
+      value: "test result: ok"
+    timeout: 8000
+  - action: validate_exit_code
+    params:
+      value: "0"
+    timeout: 5000
+
+  # The authoritative server-side write-boundary gate (StoreFactGated dispatch):
+  # ground -> score -> quarantine -> dedup -> persist, plus the gated-write IPC
+  # protocol + hardened frame reader + `simard memory remember` write tool.
+  - action: run
+    params:
+      command: "cargo test --locked --lib server_gate_tests"
+    timeout: 600000
+  - action: wait_for_output
+    params:
+      value: "test result: ok"
+    timeout: 8000
+  - action: validate_exit_code
+    params:
+      value: "0"
+    timeout: 5000
+
+  - action: run
+    params:
+      command: "cargo test --locked --lib tests_gated_write_2679"
+    timeout: 600000
+  - action: wait_for_output
+    params:
+      value: "test result: ok"
+    timeout: 8000
+  - action: validate_exit_code
+    params:
+      value: "0"
+    timeout: 5000
+
+  - action: run
+    params:
+      command: "cargo test --locked --lib operator_cli::memory::remember_tests"
+    timeout: 600000
+  - action: wait_for_output
+    params:
+      value: "test result: ok"
+    timeout: 8000
+  - action: validate_exit_code
+    params:
+      value: "0"
+    timeout: 5000
+
+  # The distillation pass contract still holds end-to-end: threshold skip,
+  # store + mark-everything, retry-safety on recipe error, quarantine gate,
+  # identity dedup, computed confidence.
+  - action: run
+    params:
+      command: "cargo test --locked --lib memory_consolidation::distillation_tests"
+    timeout: 600000
+  - action: wait_for_output
+    params:
+      value: "test result: ok"
+    timeout: 8000
+  - action: validate_exit_code
+    params:
+      value: "0"
+    timeout: 5000
+
+  # Process-boundary capstone (the true outside-in proof): the REAL `simard`
+  # binary — the exact process the distiller agent spawns — reaches a LIVE
+  # memory IPC socket and drives the write-boundary gate. A grounded fact
+  # stores (exit 0) and is retrievable, an ungrounded fact is quarantined
+  # (exit 4), a missing daemon exits 3 (no un-gated fallback), a malformed
+  # invocation exits 2, and `remember-procedure` stores. No JSON document is
+  # ever parsed on this path.
+  - action: run
+    params:
+      command: "cargo test --locked --test bin_simard_memory_remember_cli"
+    timeout: 600000
+  - action: wait_for_output
+    params:
+      value: "test result: ok"
+    timeout: 8000
+  - action: validate_exit_code
+    params:
+      value: "0"
+    timeout: 5000
diff --git a/tests/qa-scenarios/distill-ansi-step-output-parse.yaml b/tests/qa-scenarios/distill-ansi-step-output-parse.yaml
deleted file mode 100644
index 62245616..00000000
--- a/tests/qa-scenarios/distill-ansi-step-output-parse.yaml
+++ /dev/null
@@ -1,66 +0,0 @@
-name: distill-ansi-step-output-parse
-app_type: cli
-description: |
-  Verify episode→fact distillation recovers the agent's `{ "facts": [...] }`
-  answer when the `--output-format json` envelope's `distill` step `output`
-  carries ANSI-coded tracing-log noise instead of clean JSON (the t=7919 cycle:
-  the failing step output began with a dimmed `\x1b[2m2026-06-28T06:38:25…`
-  timestamp prefix). Raw `ESC` (0x1b) bytes are invalid inside JSON, so before
-  the fix a colourised / log-interleaved facts object failed `serde_json` and a
-  full 20-episode batch silently deferred for a cycle. `scan_for_facts_object`
-  now strips ANSI escapes before the balanced-brace scan, recovering the buried
-  payload. Proven by the hermetic in-process unit tests this scenario drives
-  (no network, no live host mutation). The CLI runner rejects any non-zero exit,
-  so a failing test fails the scenario.
-agents:
-  - name: simard-cli
-    type: cli
-    command: cargo
-steps:
-  # Production path: the recipe-runner-rs JSON envelope's distill-step output is
-  # ANSI-coded log noise with the facts object colourised inline; the parser
-  # mines and parses it instead of erroring "step output did not contain a
-  # parseable { facts } object". First invocation may compile the test binary.
-  - action: run
-    params:
-      command: "cargo test --locked --lib memory_consolidation::distillation::unit_tests::parse_recipe_output_full_recovers_facts_from_ansi_coded_step_output"
-    timeout: 600000
-  - action: wait_for_output
-    params:
-      value: "test result: ok"
-    timeout: 8000
-  - action: validate_exit_code
-    params:
-      value: "0"
-    timeout: 5000
-
-  # Facts-only wrapper: ANSI log lines (exact failing `\x1b[2m`+timestamp
-  # excerpt) around the facts object are stripped and the facts recovered.
-  - action: run
-    params:
-      command: "cargo test --locked --lib memory_consolidation::distillation::unit_tests::parse_recipe_output_recovers_facts_from_ansi_log_noise"
-    timeout: 300000
-  - action: wait_for_output
-    params:
-      value: "test result: ok"
-    timeout: 8000
-  - action: validate_exit_code
-    params:
-      value: "0"
-    timeout: 5000
-
-  # Stripper unit: CSI/SGR codes are removed, plain + multi-byte UTF-8 text is
-  # preserved, and a JSON-escaped `\u001b` (ASCII run, not a raw ESC) is left
-  # untouched so legitimate fact content is never mangled.
-  - action: run
-    params:
-      command: "cargo test --locked --lib memory_consolidation::distillation::unit_tests::strip_ansi_escapes_removes_csi_and_preserves_text_and_utf8"
-    timeout: 300000
-  - action: wait_for_output
-    params:
-      value: "test result: ok"
-    timeout: 8000
-  - action: validate_exit_code
-    params:
-      value: "0"
-    timeout: 5000
diff --git a/tests/qa-scenarios/distill-pretty-fact-launcher-substring-parse.yaml b/tests/qa-scenarios/distill-pretty-fact-launcher-substring-parse.yaml
deleted file mode 100644
index 2360a042..00000000
--- a/tests/qa-scenarios/distill-pretty-fact-launcher-substring-parse.yaml
+++ /dev/null
@@ -1,83 +0,0 @@
-name: distill-pretty-fact-launcher-substring-parse
-app_type: cli
-description: |
-  Verify episode→fact distillation preserves a fact's `content` when the distill
-  agent emits its `{ "facts": [...] }` answer PRETTY-PRINTED and a legitimate
-  fact `"content"` line literally quotes the `launching copilot binary=` launcher
-  substring (issue #2570).
-
-  Before the fix, the shared `is_copilot_launcher_line` predicate matched any
-  physical line *containing* that substring, so the line-dropping
-  `strip_recipe_noise` view (tried first in `scan_for_facts_object`) discarded
-  the whole `"content": …` line. The remaining object still parsed with an
-  empty, defaulted `content`; because its `source_episode_id` was non-empty it
-  was returned as a "grounded-capable" answer before the line-preserving
-  `strip_ansi` view was tried, so the fact's real content was silently lost and
-  the reliability hard gate then quarantined the now-empty fact — a fact-yield
-  regression.
-
-  The fix guards `is_copilot_launcher_line` so a line beginning (after trimming)
-  with a JSON structural token (`{`, `"`, `[`) is never launcher noise, honouring
-  the module's documented "a JSON payload line is never launcher noise" contract.
-  Because that predicate / `strip_recipe_noise` is a shared chokepoint used by
-  decide, orient, engineer-lifecycle, merge-judge, progress-checker AND distill,
-  this scenario also drives the cross-consumer regression tests proving those
-  consumers still strip real launcher-noise lines.
-
-  Proven by the hermetic in-process unit tests this scenario drives (no network,
-  no live host mutation). The CLI runner rejects any non-zero exit, so a failing
-  test fails the scenario.
-agents:
-  - name: simard-cli
-    type: cli
-    command: cargo
-steps:
-  # Headline distill regression: the pretty-printed fact content quoting the
-  # launcher substring is preserved (not line-dropped to empty), and the
-  # preserved grounded fact clears the reliability promotion gate. First
-  # invocation may compile the test binary.
-  - action: run
-    params:
-      command: "cargo test --locked --lib -- memory_consolidation::distillation::issue_2570_pretty_fact_launcher_substring_tests"
-    timeout: 600000
-  - action: wait_for_output
-    params:
-      value: "test result: ok"
-    timeout: 8000
-  - action: validate_exit_code
-    params:
-      value: "0"
-    timeout: 5000
-
-  # Shared chokepoint: a JSON structural-token line (`{`, `"`, `[`) quoting the
-  # launcher substring is never classified as launcher noise, while every real
-  # launcher shape is still stripped by `strip_recipe_noise`.
-  - action: run
-    params:
-      command: "cargo test --locked --lib -- recipe_output::extract::issue_2570_structural_token_guard_tests"
-    timeout: 300000
-  - action: wait_for_output
-    params:
-      value: "test result: ok"
-    timeout: 8000
-  - action: validate_exit_code
-    params:
-      value: "0"
-    timeout: 5000
-
-  # Cross-consumer safety: decide, orient, engineer-lifecycle, merge-judge and
-  # progress-checker still strip the real launcher preamble after the guard,
-  # while the shared cleaner preserves a `"`-leading fact content line quoting
-  # the substring. A single filter runs every `issue_2570` regression test.
-  - action: run
-    params:
-      command: "cargo test --locked --lib -- issue_2570_cross_consumer"
-    timeout: 300000
-  - action: wait_for_output
-    params:
-      value: "test result: ok"
-    timeout: 8000
-  - action: validate_exit_code
-    params:
-      value: "0"
-    timeout: 5000
diff --git a/tests/qa-scenarios/distill-trailing-comma-parse.yaml b/tests/qa-scenarios/distill-trailing-comma-parse.yaml
deleted file mode 100644
index 181a3c52..00000000
--- a/tests/qa-scenarios/distill-trailing-comma-parse.yaml
+++ /dev/null
@@ -1,89 +0,0 @@
-name: distill-trailing-comma-parse
-app_type: cli
-description: |
-  Verify episode→fact distillation tolerates a trailing comma in the distiller
-  agent's `{ "facts": [...] }` JSON (issue #2658 — the residual "100%
-  parse-failure" shape after the launcher-banner / ANSI fixes). A trailing comma
-  before a `}` or `]` is the single most common real-world LLM JSON defect; the
-  balanced-brace scan still finds the span, but strict `serde_json` rejected the
-  WHOLE object, so the batch was silently deferred every cycle and
-  `distill_parse_success_rate` collapsed toward 0. A new string-aware,
-  last-resort `strip_json_trailing_commas` recovery view (a provable no-op on
-  valid JSON) is retried only after the strict parse fails, so one cosmetic comma
-  no longer drops the batch — WITHOUT weakening precision (a comma inside a
-  fact's string content is preserved, and a genuinely malformed object still
-  fails). Proven by the hermetic in-process unit tests + the deterministic
-  before/after parse-recovery benchmark this scenario drives (no network, no live
-  host mutation). The CLI runner rejects any non-zero exit, so a failing test
-  fails the scenario.
-agents:
-  - name: simard-cli
-    type: cli
-    command: cargo
-steps:
-  # Stripper primitive: a trailing comma before `}`/`]` (incl. pretty-printed
-  # whitespace) is removed to valid JSON, while a comma inside string content and
-  # a genuinely-malformed (elided-element) object are left untouched. Zero-alloc
-  # borrow on valid JSON proves the clean path is byte-identical. First
-  # invocation may compile the test binary.
-  - action: run
-    params:
-      command: "cargo test --locked --lib recipe_output::extract::tests::strip_trailing_commas"
-    timeout: 600000
-  - action: wait_for_output
-    params:
-      value: "test result: ok"
-    timeout: 8000
-  - action: validate_exit_code
-    params:
-      value: "0"
-    timeout: 5000
-
-  # Production path: a bare trailing-comma facts object recovers >= 1 fact
-  # instead of dropping the whole batch (the headline #2658 acceptance).
-  - action: run
-    params:
-      command: "cargo test --locked --lib memory_consolidation::distillation::unit_tests::parse_recovers_bare_trailing_comma_facts_object"
-    timeout: 300000
-  - action: wait_for_output
-    params:
-      value: "test result: ok"
-    timeout: 8000
-  - action: validate_exit_code
-    params:
-      value: "0"
-    timeout: 5000
-
-  # Precision guard: a comma inside a fact's `content` string is never corrupted,
-  # and a genuinely malformed (elided `,,`) object still fails — leniency never
-  # widens to accept broken JSON.
-  - action: run
-    params:
-      command: "cargo test --locked --lib -- memory_consolidation::distillation::unit_tests::parse_trailing_comma_recovery_never_corrupts_string_content memory_consolidation::distillation::unit_tests::parse_still_fails_on_genuinely_malformed_non_trailing_comma"
-    timeout: 300000
-  - action: wait_for_output
-    params:
-      value: "test result: ok"
-    timeout: 8000
-  - action: validate_exit_code
-    params:
-      value: "0"
-    timeout: 5000
-
-  # Deterministic before/after parse-recovery benchmark: over a batch that
-  # reproduces the residual 100% shape, the strict baseline fails EVERY one
-  # (failure-rate 1.000) and the shipped tolerant parser recovers EVERY one
-  # (failure-rate 0.000) — the in-process analog of the live
-  # `distill_parse_success_rate` self-metric moving off the floor.
-  - action: run
-    params:
-      command: "cargo test --locked --lib memory_consolidation::distillation_fact_yield_bench::distill_parse_failure_rate_benchmark_before_1000_after_0000 -- --nocapture"
-    timeout: 300000
-  - action: wait_for_output
-    params:
-      value: "before_failure_rate=1.000 after_failure_rate=0.000"
-    timeout: 8000
-  - action: validate_exit_code
-    params:
-      value: "0"
-    timeout: 5000