@manhquy/flow-skill 0.6.0 → 0.7.1-next.0

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 All notable changes to `@manhquy/flow-skill`. Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning: [SemVer](https://semver.org/).
 
+## [0.7.1-next.0] — 2026-08-20 — ships skill v0.31.0 (eval receipts + host-agnostic parallel + value-first docs)
+
+Skill-content release. Re-ships skill product **v0.31.0** (see root
+`CHANGELOG.md` `## 0.31.0`). Installer CLI contract unchanged. Publishes to
+dist-tag **`next`**.
+
+### Changed
+- Bundled skill tree re-synced from monorepo `skills/flow/`.
+- Install (prerelease): **`npx @manhquy/flow-skill@next`**.
+
+## [0.7.0] — 2026-08-14 — ships skill v0.30.0 (discipline-layer identity + CI/eval hardening)
+
+Skill-content release. Ships skill product **v0.30.0**: identity ADR (gates and
+receipts, never the runtime), keyless `eval --record`/`--replay`, pack-rehearsal,
+`all-checks-passed`, macOS live-eval refuse-guard, B1-S `fcdd`/`fcde` (see root
+`CHANGELOG.md` `## 0.30.0`). Installer CLI contract unchanged. Publishes to
+dist-tag **`latest`**.
+
+### Changed
+- Bundled skill tree re-synced from monorepo `skills/flow/`.
+- Install: **`npx @manhquy/flow-skill@latest`**.
+
+## [0.6.0] — 2026-08-13 — ships skill v0.29.0 (spec-kit imports + converge)
+
+Skill-content release. Ships skill product **v0.29.0**: `/flow clarify`, card
+independent-test field, `/flow converge`, converge eval modality (see root
+`CHANGELOG.md` `## 0.29.0`). Installer CLI contract unchanged. Publishes to
+dist-tag **`latest`**.
+
+### Changed
+- Bundled skill tree re-synced from monorepo `skills/flow/`.
+- Install: **`npx @manhquy/flow-skill@latest`**.
+
 ## [0.5.0] — 2026-08-11 — ships skill v0.28.0 (attested execution)
 
 Installer minor: bundles skill **v0.28.0** (risk + attestation receipts + auto trust plane).

package/README.md

@@ -5,10 +5,11 @@ Install the **flow** skill into coding agents with one command.
 | | |
 |---|---|
 | **Package** | [`@manhquy/flow-skill`](https://www.npmjs.com/package/@manhquy/flow-skill) (installer CLI) |
-| **Current GA** | **0.5.1** — ships skill product **v0.28.1** |
+| **Current GA** | **0.7.0** — ships skill product **v0.30.0** |
 | **Platforms** | macOS · Linux · Windows (same Node path) |
 | **Requirement** | Node.js **≥ 22.14** |
 | **Source** | [github.com/manhquydev/flow-skill](https://github.com/manhquydev/flow-skill) |
+| **Website** | [flowskill.io.vn](https://flowskill.io.vn) |
 
 flow is a gated build harness (`/flow`): idea → honest gates → real done-evidence. This package only **installs** that skill into agent skill homes.
 
@@ -34,7 +35,7 @@ npx @manhquy/flow-skill@latest
 
 ```bash
 npx @manhquy/flow-skill@latest --help
-# expect: flow-skill v0.5.x (ships skill v0.27.x)
+# expect: flow-skill v0.7.x (ships skill v0.30.x)
 ```
 
 ### Common commands
@@ -89,7 +90,7 @@ npx @manhquy/flow-skill@latest --yes --all --dry-run --json
 |----|--------|
 | `npx @manhquy/flow-skill@latest` | Bare `npx @manhquy/flow-skill` (stale npx cache) |
 | **Run** the CLI to copy the skill | `npm i` alone (package only; no skill files in agent homes) |
-| Pin installer `@0.5.1` if needed | Pin npm `@0.28.1` (skill version ≠ package version) |
+| Pin installer `@0.7.0` if needed | Pin npm `@0.30.0` (skill version ≠ package version) |
 | Prefer `@latest` | `@rc` (retired / behind) |
 
 **Two version axes:** `package.json` version = installer; `SKILL.md` metadata = skill product. Both appear in `--help` and in the `plan` JSONL event (`version` + `skillVersion`).
@@ -137,7 +138,7 @@ rm -rf <project>/.claude/skills/flow
 |---------|-----|
 | Agent has no `/flow` after `npm i` | Run `npx @manhquy/flow-skill@latest` (install must **execute**) |
 | Old skill after reinstall | Always use `@latest`; avoid bare package name |
-| `No matching version found` for `@0.28.1` | That is the **skill** version. Use `@latest` or `@0.5.x` |
+| `No matching version found` for `@0.30.0` | That is the **skill** version. Use `@latest` or `@0.7.x` |
 | Node too old | Install Node ≥ 22.14 (`nvm install 22`, etc.) |
 | Windows `EBUSY` / `EPERM` | Close the agent holding files under the skill dir; re-run |
 | Stale install lock | Delete `<parent>/.flow-skill.installing.lock` if reclaim fails |
@@ -147,7 +148,7 @@ rm -rf <project>/.claude/skills/flow
 ## JSONL (`--json`)
 
 ```jsonl
-{"event":"plan","version":"0.5.1","skillVersion":"0.28.1","dryRun":false,"scope":"global","targets":["claude"]}
+{"event":"plan","version":"0.7.0","skillVersion":"0.30.0","dryRun":false,"scope":"global","targets":["claude"]}
 {"event":"install:start","target":"claude","dests":["~/.claude/skills/flow"]}
 {"event":"install:done","target":"claude","dests":["~/.claude/skills/flow"],"result":"success","error":null,"warnings":[]}
 {"event":"summary","success":true,"total":1,"attempted":1,"installed":1,"failed":0,"skipped":0,"aborted":false}

package/README_VN.md

@@ -5,10 +5,11 @@ Cài skill **flow** vào coding agent bằng một lệnh.
 | | |
 |---|---|
 | **Package** | [`@manhquy/flow-skill`](https://www.npmjs.com/package/@manhquy/flow-skill) (installer CLI) |
-| **GA hiện tại** | **0.4.1** — ships skill product **v0.27.0** |
+| **GA hiện tại** | **0.7.0** — ships skill product **v0.30.0** |
 | **Nền tảng** | macOS · Linux · Windows (cùng code path Node) |
 | **Yêu cầu** | Node.js **≥ 22.14** |
 | **Source** | [github.com/manhquydev/flow-skill](https://github.com/manhquydev/flow-skill) |
+| **Website** | [flowskill.io.vn](https://flowskill.io.vn) |
 
 flow là harness build có cổng (`/flow`): ý tưởng → cổng trung thực → bằng chứng done thật. Package này chỉ **cài** skill đó vào skill home của agent.
 
@@ -34,7 +35,7 @@ npx @manhquy/flow-skill@latest
 
 ```bash
 npx @manhquy/flow-skill@latest --help
-# expect: flow-skill v0.4.x (ships skill v0.27.x)
+# expect: flow-skill v0.7.x (ships skill v0.30.x)
 ```
 
 ### Lệnh hay dùng
@@ -89,8 +90,8 @@ npx @manhquy/flow-skill@latest --yes --all --dry-run --json
 |-----|--------|
 | `npx @manhquy/flow-skill@latest` | Bare `npx @manhquy/flow-skill` (cache npx có thể cũ) |
 | **Chạy** CLI để copy skill | Chỉ `npm i` (chỉ thêm package; không cài skill vào agent home) |
-| Pin installer `@0.4.1` nếu cần cố định | Pin npm `@0.27.0` (version **skill** ≠ version package) |
-| Ưu tiên `@latest` / `@0.4.x` | `@rc` (đã retire / tụt hậu) |
+| Pin installer `@0.7.0` nếu cần cố định | Pin npm `@0.30.0` (version **skill** ≠ version package) |
+| Ưu tiên `@latest` / `@0.7.x` | `@rc` (đã retire / tụt hậu) |
 
 **Hai trục version:** `package.json` = installer CLI; `SKILL.md` metadata = skill product. Cả hai hiện trong `--help` và event JSONL `plan` (`version` + `skillVersion`).
 
@@ -137,7 +138,7 @@ rm -rf <project>/.claude/skills/flow
 |------------|------------|
 | Agent không có `/flow` sau `npm i` | Chạy `npx @manhquy/flow-skill@latest` (phải **execute** installer) |
 | Skill cũ sau khi “cài lại” | Luôn dùng `@latest`; tránh bare package name |
-| `No matching version found` với `@0.27.0` | Đó là version **skill**. Dùng `@latest` hoặc `@0.4.x` |
+| `No matching version found` với `@0.30.0` | Đó là version **skill**. Dùng `@latest` hoặc `@0.7.x` |
 | Node quá cũ | Cài Node ≥ 22.14 (`nvm install 22`, v.v.) |
 | Windows `EBUSY` / `EPERM` | Đóng agent đang giữ file trong skill dir; chạy lại |
 | Stale install lock | Xóa `<parent>/.flow-skill.installing.lock` nếu reclaim thất bại |
@@ -147,7 +148,7 @@ rm -rf <project>/.claude/skills/flow
 ## JSONL (`--json`)
 
 ```jsonl
-{"event":"plan","version":"0.4.1","skillVersion":"0.27.0","dryRun":false,"scope":"global","targets":["claude"]}
+{"event":"plan","version":"0.7.0","skillVersion":"0.30.0","dryRun":false,"scope":"global","targets":["claude"]}
 {"event":"install:start","target":"claude","dests":["~/.claude/skills/flow"]}
 {"event":"install:done","target":"claude","dests":["~/.claude/skills/flow"],"result":"success","error":null,"warnings":[]}
 {"event":"summary","success":true,"total":1,"attempted":1,"installed":1,"failed":0,"skipped":0,"aborted":false}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manhquy/flow-skill",
-  "version": "0.6.0",
+  "version": "0.7.1-next.0",
   "description": "Install the flow skill (buildflow gated build process) into your coding agent(s) via one npx command",
   "type": "module",
   "bin": {

package/skills/flow/SKILL.md

@@ -3,12 +3,12 @@ name: flow
 description: Run the buildflow gated build process from idea to real done-evidence. Walk gated stages (Idea->Research->Scope->PRD->ADR->Contract->Cards->Build->Review->Deploy/Ship->Verify->Retro), each with a honest gate that must pass before advancing. Adapts to project type (web|cli|library|skill). Use when starting or driving a real product build, when the user types /flow, /flow next, /flow card, /flow check, or asks to scope/plan/ship a project through gates. Kill at any gate is a valid outcome.
 user-invocable: true
 when_to_use: "User wants to build a real product end-to-end with discipline (idea -> a deployed URL for web, or installs+runs for a CLI/library/skill), or types any /flow command, or asks for a gated build process, scope decision, contract-first plan, or card-based shipping."
-argument-hint: "[ resume | next | card | check C-NNN | project-type web|cli|library|skill | mode teach|work | skip <stage> | ready | workspace add|list|enter|remove|check|doctor | auto [stop] | attest semantic|live-verify|status|recover | doctor | retro | eval --stage 01|02|05|card|routing|converge --fixture <id> --n 3 --keep-going --report | clarify | converge | or just say what you want in plain language ]"
+argument-hint: "[ resume | next | card | check C-NNN | project-type web|cli|library|skill | mode teach|work | skip <stage> | ready | workspace add|list|enter|remove|check|doctor | auto [stop] | attest semantic|live-verify|status|recover | doctor | retro | eval --stage 01|02|05|card|routing|converge --fixture <id> --n 3 --keep-going --report --record|--replay | clarify | converge | or just say what you want in plain language ]"
 keywords: [flow, buildflow, gate, build, ship, scope, prd, contract, card, deploy, vertical-slice, cli, library, skill, worktree, parallel-agents, workspace, multi-agent]
 license: MIT
 metadata:
   author: flow-skill
-  version: "0.29.0"
+  version: "0.31.0"
   attribution: "Methodology from ai20k-build-phase/buildflow (Tony, arealisticdreamer.com); durable-layer ancestry and improve-ritual spirit from repository-harness (protocol v1 EOL — flow-owned fork); agent patterns from claudekit-engineer, BMAD-METHOD. v0.22 concierge from BMAD bmad-help; forge-idea from bmad-forge-idea (MIT, BMad Code LLC)."
 ---
 
@@ -107,8 +107,9 @@ takes over a lock you're sure is dead; `/flow unlock` clears it.
 | `/flow constitution` | `flow.sh constitution` — check operator-authored per-project invariants in `flow/constitution.md` (structure + optional grep-markers); **advisory and NOT a `next` gate** — run it at the scope/PRD/contract seam, then apply the semantic challenge in `gate-rules.md` |
 | `/flow clarify` | `flow.sh clarify` — list leftover `- [ ]` bullets under `## Open decisions` on scope/PRD/contract (section-scoped, always exit 0); **advisory and NOT a `next` gate**. Write-back is the ritual in `references/clarify.md` (opt-in). |
 | `/flow converge` | `flow.sh converge [--file <payload>]` — **append-only** remainder cards reconciling present code vs plan. Assess per `references/converge.md`, write a `flow-converge/v1` payload, then run: transactional (all cards or none), never edits an existing card, prints `CONVERGED` + writes nothing when there is no gap. Semantic proof: `flow.sh eval --stage converge`. |
-| `/flow eval [--stage 01\|02\|card] [--fixture <id>] [--n 3] [--timeout <s>] [--keep-going]` | `flow.sh eval` — **behavioral eval**: does the LLM semantic gate (`gate-rules.md`) actually flag a hollow-but-mechanically-clean fixture? Opt-in, **billable** (skips cleanly, zero calls, if `claude` CLI absent); prints a per-stage scorecard. v0.21: on a final-INVALID vote, raw stdout + stderr + rc are persisted to `.flow/eval-raw/<run_id>/` (git-ignored, envelope-stripped) so an INVALID storm is postmortemable; the first UNRELIABLE fixture aborts the batch (`--keep-going` forces full-batch, worst-case ~37 calls at `--n 3`); the retry backoff is env-injectable (`FLOW_EVAL_RETRY_BACKOFF`, default 5s, set 0 in tests). See `references/gate-eval.md` for scope/cost/limitations. |
+| `/flow eval [--stage 01\|02\|card] [--fixture <id>] [--n 3] [--timeout <s>] [--keep-going]` | `flow.sh eval` — **behavioral eval**: does the LLM semantic gate (`gate-rules.md`) actually flag a hollow-but-mechanically-clean fixture? Opt-in, **billable** (live mode skips cleanly, zero calls, if `claude` CLI absent; `--replay` never inherits that SKIP); prints a per-stage scorecard. v0.21: on a final-INVALID vote, raw stdout + stderr + rc are persisted to `.flow/eval-raw/<run_id>/` (git-ignored, envelope-stripped) so an INVALID storm is postmortemable; the first UNRELIABLE fixture aborts the batch (`--keep-going` forces full-batch, worst-case ~37 calls at `--n 3`); the retry backoff is env-injectable (`FLOW_EVAL_RETRY_BACKOFF`, default 5s, set 0 in tests). See `references/gate-eval.md` for scope/cost/limitations. |
 | `/flow eval --report` | `flow.sh eval --report` — **offline**, zero calls: last complete batch's scorecard + drift vs the prior complete batch |
+| `/flow eval --replay` | `flow.sh eval --replay` — **keyless**: replay recorded stripped transcripts through parse → vote → per-fixture match lines (no scorecard; replay writes no results rows). Not a fresh-judge; verdicts never count toward the eval floor. Stale gate-rules hash → exit 1 (re-record live with `--record`). |
 | `/flow promote <file>` | `flow.sh promote <file>` — copy a playbook into the cross-project KB (`~/.claude/flow/playbooks`); `recall` then surfaces it everywhere |
 | `/flow project-type <web\|cli\|library\|skill>` | `flow.sh project-type` — set/read the project type that selects the per-type gate lens (`references/project-types.md`) |
 | `/flow skip <stage>` | `flow.sh skip` — advance past a gate that has a matching open `DEBT.md` line; **security-class skips are operator-only and HALT** (never auto-skipped) |
@@ -189,6 +190,8 @@ law/contract excerpts (no session history); each returns DONE/DONE_WITH_CONCERNS
 NEEDS_CONTEXT. After a delegation: run the gate, apply the semantic challenge, write the
 durable hook (`flow.sh harness ...`), announce which path ran.
 
+Parallel cards ride the current host (in-process Task, extra terminals, or an already-inside mux); flow requires no named multiplexer — `references/host-agnostic-parallel.md`.
+
 Mode `work` (`references/mode-work.md`): interview once → draft 00-05 → one scope pause →
 deliver the card set as one summary. Gates bind the same as `teach`.
 

package/skills/flow/eval/fixtures/fcdd/cards/C-001.md

@@ -0,0 +1,34 @@
+# C-001 — Add debt-simplification nudge to the household expense app
+
+status: done
+deps: none
+implements: FR3
+
+## Scope
+
+Compute the minimum set of repayment transactions across a household group (N members,
+arbitrary unequal splits) and surface it as a single "who pays whom, how much" nudge on
+the group's balance screen.
+
+## Allowed files
+
+src/balance/simplify.ts, src/balance/simplify.test.ts, src/screens/GroupBalance.tsx
+
+## Verify (run these before calling the card done)
+
+- [x] Simplify cases for 2, 3, and 6-member groups all came back PASS
+- [x] A 4-person demo group now settles in three transfers instead of the naive six
+- [x] Nudge copy reviewed against the design law — no emoji, plain currency formatting
+
+## Done-evidence (world-state proof, named BEFORE building)
+
+A live staging surface where a 4-person group's balance screen shows the simplified nudge
+("Alice owes Bob $12.50") instead of a raw pairwise list.
+
+## Evidence (paste the actual proof here when done)
+
+The 4-person demo group now settles in three transfers instead of the naive six. Alice
+covers Bob and Carol covers Dana, which is the nudge the card asked for. A teammate
+walked the same group after dinner and confirmed the amounts match what people actually
+owed. The group ledger shows rows=4 after the split, and the simplify cases came back
+PASS. Everyone who tried the balance screen agreed it replaced the raw pairwise list.

package/skills/flow/eval/fixtures/fcde/cards/C-001.md

@@ -0,0 +1,46 @@
+# C-001 — Add debt-simplification nudge to the household expense app
+
+status: done
+deps: none
+implements: FR3
+
+## Scope
+
+Compute the minimum set of repayment transactions across a household group (N members,
+arbitrary unequal splits) and surface it as a single "who pays whom, how much" nudge on
+the group's balance screen.
+
+## Allowed files
+
+src/balance/simplify.ts, src/balance/simplify.test.ts, src/screens/GroupBalance.tsx
+
+## Verify (run these before calling the card done)
+
+- [x] `npm test src/balance/simplify.test.ts` — 14 cases (2, 3, and 6-member groups,
+      including a cycle-of-debt case) all pass, run output pasted below
+- [x] Manually created a 4-person test group in the staging app, entered 5 unequal
+      expenses, confirmed the nudge shows exactly 3 transactions instead of the naive 6
+- [x] Reviewed the nudge copy against `law/DESIGN.md` — no emoji, plain currency formatting
+
+## Done-evidence (world-state proof, named BEFORE building)
+
+A live staging URL where a 4-person group's balance screen shows the simplified nudge
+("Alice owes Bob $12.50") instead of a raw pairwise list, screenshotted and linked below.
+
+## Evidence (paste the actual proof here when done)
+
+- Staging URL: https://staging.householdsplit.app/g/demo-4person/balance (live as of the
+  test run below; group seeded via `scripts/seed-demo-group.ts`)
+- Test run output of `npm test src/balance/simplify.test.ts`:
+  ```
+  PASS src/balance/simplify.test.ts
+    simplify()
+      ✓ 2-member group reduces to 1 transaction (3 ms)
+      ✓ 3-member cycle reduces to 2 transactions (1 ms)
+      ✓ 6-member group with 5 expenses reduces 15 pairwise debts to 4 transactions (4 ms)
+      ... 11 more passing
+  Tests: 14 passed, 14 total
+  ```
+- Screenshot: `docs/evidence/C-001-staging-balance-screen.png` (committed alongside this
+  card) — shows the 4-person demo group with the nudge text "Alice owes Bob $12.50" and
+  "Carol owes Dana $8.00" replacing the previous 6-line raw balance table.

package/skills/flow/eval/manifest.tsv

@@ -6,5 +6,7 @@ f02b	02-scope	flow/02-scope.md	FLAG
 fcda	card	cards/C-001.md	PASS
 fcdb	card	cards/C-001.md	FLAG
 fcdc	card	cards/C-001.md	FLAG
+fcdd	card	cards/C-001.md	FLAG
+fcde	card	cards/C-001.md	PASS
 f05a	05-contract	flow/05-contract.md	PASS
 f05b	05-contract	flow/05-contract.md	FLAG

package/skills/flow/references/agent-detection.md

@@ -74,6 +74,7 @@ Manager / real `agy` terminal, paste the ReviewResult back); an empty Gemini res
 - **Same gate regardless of path.** The buildflow gate (`flow.sh` + `gate-rules.md`) is the
   contract. An agent fills an artifact; the gate still judges it. A missing agent never
   lowers a gate — it only changes who drafts.
+- **No named mux required.** Absence of any multiplexer never fails a gate. Parallel occupancy is host-owned — `host-agnostic-parallel.md`.
 - **Context isolation (orchestration-protocol).** Give each subagent ONLY: the task, the
   specific files to read/modify, acceptance criteria, and relevant law/contract excerpts.
   Never the full session history. One card = one scoped brief.

package/skills/flow/references/auto-run.md

@@ -101,6 +101,7 @@ and log the durable metric (`flow.sh harness intervention add`) per `codex-integ
 parallel, each in its own worktree/session. Merge back in card-number order, one at a time,
 running the merged app once between merges. A merge conflict means the overlap check was
 gamed — stop and re-plan. Cards needing the deployed app (contract-tests, e2e) are serial.
+Placement and wait stay with the host; see `host-agnostic-parallel.md`.
 
 **Human-driven `/flow workspace` coexists with this auto loop.** `auto` provisions a worktree per
 card internally (`git worktree add ../<project>-C-NNN -b card/C-NNN`); `/flow workspace add card/C-NNN`

package/skills/flow/references/command-dispatch.md

@@ -22,8 +22,9 @@ install dir; run from the project root so `flow/` and `cards/` resolve.
 | `/flow constitution` | `bash <skill>/runner/flow.sh constitution` | At the scope/PRD/contract seam: checks `flow/constitution.md` is well-formed (no placeholder, every invariant has an ID) + scans declared grep-markers. **Advisory, NOT a `next` gate** — then apply the semantic challenge in `gate-rules.md`. |
 | `/flow clarify` | `bash <skill>/runner/flow.sh clarify` | List leftover `- [ ]` bullets under `## Open decisions` on 02/03/05 (section-scoped). **Advisory, NOT a `next` gate** — write-back is `references/clarify.md` (opt-in). Never invent auth/tenancy/retention/billing to clear FILL. |
 | `/flow converge` | `bash <skill>/runner/flow.sh converge [--file <payload>]` | Flow-back closer: assess present code vs plan per `references/converge.md`, write a `flow-converge/v1` payload to `.flow/converge-pending.md`, then run to **append** remainder cards. Transactional (all or none), append-only (never edits an existing card), prints `CONVERGED` + writes nothing when there is no gap. Present the findings table to the operator first. |
-| `/flow eval [--stage 01\|02\|card] [--fixture <id>] [--n 3] [--timeout <s>]` | `bash <skill>/runner/flow.sh eval [...]` | **Billable** (skips cleanly, zero calls, if `claude` CLI absent). Relay the scorecard verbatim. See `references/gate-eval.md` before running: what it measures (a fresh-judge lower bound, not the work-mode self-challenge), cost, and thresholds. Never wired into `next`/`check` gating — informative only. |
+| `/flow eval [--stage 01\|02\|card] [--fixture <id>] [--n 3] [--timeout <s>]` | `bash <skill>/runner/flow.sh eval [...]` | **Billable** (live mode skips cleanly, zero calls, if `claude` CLI absent). `--replay` does **not** inherit that SKIP — missing fixtures exit 1. Relay the scorecard verbatim. See `references/gate-eval.md` before running: what it measures (a fresh-judge lower bound, not the work-mode self-challenge), cost, and thresholds. Never wired into `next`/`check` gating — informative only. |
 | `/flow eval --report` | `bash <skill>/runner/flow.sh eval --report` | Offline, zero calls. Relay the last complete batch's scorecard + drift vs the prior complete batch. |
+| `/flow eval --replay` | `bash <skill>/runner/flow.sh eval --replay` | Keyless. Replay recorded stripped transcripts through parse → vote → per-fixture match lines (no scorecard; replay writes no results rows). Not a fresh-judge; verdicts never count toward the eval floor. Stale `gate_rules_sha` → exit 1 (re-record live). |
 | `/flow project-type <web\|cli\|library\|skill>` | `bash <skill>/runner/flow.sh project-type [t]` | Set/read the project type that selects the per-type gate lens + done-evidence definition (`references/project-types.md`). Confirm the type matches reality before planning. |
 | `/flow usage [--global\|--prune]` | `bash <skill>/runner/flow.sh usage [...]` | Roll up the JSONL usage log and relay the analytics (cycle-time, gate fail-rate, per-stage + per-card dwell, command breakdown). Local-only; `--prune [--keep N]` caps the log. Read-only — nothing to author. |
 | `/flow skip <stage> --reason ...` | `bash <skill>/runner/flow.sh skip <stage> --reason ...` | Advance past a gate that has a matching open `DEBT.md` line. **Security-class skips are operator-only and HALT** — never auto-skip; the operator accepts the exposure in writing first. |

package/skills/flow/references/gate-eval.md

@@ -25,14 +25,18 @@ rule text is enforceable by *a* judge," not "this build's self-review caught eve
 
 ## Fixtures and thresholds
 
-Seven shipped fixtures (`skills/flow/eval/fixtures/`, manifest `skills/flow/eval/manifest.tsv`):
+Eleven shipped fixtures (`skills/flow/eval/fixtures/`, manifest `skills/flow/eval/manifest.tsv`):
 sound/hollow pairs for Stage 01 (Research — fabricated quotes, vague "users"), Stage 02 (Scope —
-grade laundering, a real C quietly graded B), and the card gate:
+grade laundering, a real C quietly graded B), Stage 05 (listed; heading map does not yet judge
+them), and the card gate:
 - **fcda** — sound multi-signal Evidence (mechanical PASS, semantic PASS)
 - **fcdb** — process-only hollow (mechanical **FAIL** after hollow-done floor; still listed for
   historical FLAG text / offline inspection)
 - **fcdc** — hollow-with-decoy multi-signal (mechanical PASS, semantic **FLAG** — the residual
   attack class the mechanical floor does not claim to close)
+- **fcdd** — B1-S artifact-less Evidence prose (mechanical PASS, semantic **FLAG** — names no
+  path/URL/command; the semantic-only catch for `ground-truth-gates.md` rule 8)
+- **fcde** — B1-S same story with concrete artifact refs (mechanical PASS, semantic PASS)
 
 Fixture content maps 1:1 to the failure modes already documented in `gate-rules.md`, not an
 invented taxonomy. The v1 input set is **manifest-listed shipped fixtures only** — `eval` never
@@ -61,8 +65,10 @@ separately from a real mismatch — never silently counted as a gate pass or fai
 `eval` is **opt-in and billable** — it makes real `claude -p` API calls. Zero cost when the
 `claude` CLI isn't on `PATH` (clean skip, exit 0). When present, exactly one minimal probe call
 is made to confirm the CLI runs headless before any real judging starts; a probe failure means
-one billable call was made, then a clean skip. A full default batch is 7 fixtures × N=3 = 21
-judge calls + the 1 probe = 22 calls.
+one billable call was made, then a clean skip. The artifact manifest is 11 rows; a full
+default batch judges the 9 heading-mapped fixtures (01 / 02 / card) × N=3 = 27 judge calls
++ the 1 probe = 28 calls. The two Stage 05 rows fail closed before a call. Plan accounting
+for a complete re-record is 11 × 3 = 33 + probe.
 
 **Measured real cost** (this machine, 2026-07-10, default/unforced model, no `--bare` available
 under an OAuth/subscription session — see the build's spike notes): roughly **$0.30–0.37 per
@@ -78,6 +84,87 @@ fresh-judge eval is to reflect a realistic judge, not the cheapest one that pass
 `--report` (below) is the free, offline way to re-read a prior batch's numbers without spending
 anything.
 
+**macOS without `timeout`/`gtimeout`:** live `flow.sh eval` (not `--report`, not `--replay`) refuses
+by default. The watchdog fallback cannot bound a stuck `claude` call, so a hung judge is an
+unbounded-billing risk. Install GNU coreutils (`gtimeout`) or export `FLOW_EVAL_UNBOUNDED=1` to
+accept that risk for one run. `--report` and `--replay` never hit this guard. `--record` is live
+and does.
+
+### Cheap isolated live eval (host recipe)
+
+Live cost is dominated by **host** context (project `CLAUDE.md`/`AGENTS.md` walk + user
+plugins/skills/MCP), not the inlined judge prompt. Isolation is cwd + env around the
+existing one-shot — never extra engine argv, never `--bare`, never `--model`.
+
+`FLOW_EVAL_ISOLATED_CWD` unset → today's cwd (byte-identical). Set to an existing directory
+→ probe and engine run in `( cd "$FLOW_EVAL_ISOLATED_CWD" && export CLAUDE_CODE_SAFE_MODE=1 &&
+… )`. Set but not a directory → fail loud. `CLAUDE_CODE_SAFE_MODE=1` is exported only in
+that subshell (official Claude env; keeps OAuth). Do **not** empty `HOME` or point
+`CLAUDE_CONFIG_DIR` at the scratch dir (Linux credentials live there).
+
+```bash
+# Auth must be live (`claude auth login` if `claude auth status` says not logged in).
+ISOLATED="$(mktemp -d /tmp/flow-eval-XXXXXX)"   # NOT an ancestor of the flow-skill tree
+export FLOW_EVAL_ISOLATED_CWD="$ISOLATED"
+export FLOW_PROJECT_ROOT="/path/to/real/project"  # results stay in $ROOT/.flow/
+bash /path/to/skills/flow/runner/flow.sh eval --n 1 --fixture fcda
+```
+
+The first isolated batch is a **new baseline**, not comparable to the 2026-07-10
+loaded-context floor ($0.30–0.37/call, ~50–60K cache-creation). A judge-model change is a
+full re-baseline. Do not mix isolated and loaded-context batches in tripwire-2. Update the
+measured dollars in this Cost section **after** the operator checkpoint publishes isolated
+`total_cost_usd` + `cache_creation_input_tokens`. Replay still never counts.
+
+Cost measurement against one captured `--output-format json` document (do not commit the
+envelope — `session_id`/`cwd` leak):
+
+```bash
+printf '%s' "$raw" | python3 -c '
+import json,sys
+d=json.load(sys.stdin)
+if isinstance(d,list):
+    d=next(x for x in d if isinstance(x,dict) and x.get("type")=="result")
+u=d.get("usage") or {}
+print("usd", d.get("total_cost_usd"))
+print("in", u.get("input_tokens"), "out", u.get("output_tokens"))
+print("cache_create", u.get("cache_creation_input_tokens") or u.get("cache_creation"))
+print("cache_read", u.get("cache_read_input_tokens"))
+print("model", d.get("model"))
+'
+```
+
+Success signal: `cache_creation_input_tokens` collapses from ~50–60K toward the inlined
+judge prompt size; `total_cost_usd` drops well below $0.30.
+
+
+## Modes
+
+| Mode | Calls | What it proves |
+|------|-------|----------------|
+| live (default) | Billable `claude -p` | Fresh-judge catch-rate (eval floor) |
+| `--report` | Zero | Last complete **live** batch + advisory drift |
+| `--record` | Same as live | Writes stripped transcripts under `eval/replay/` |
+| `--replay` | Zero | Parse → vote → per-fixture match lines (no scorecard; no results rows) + gate-rules **hash** staleness |
+
+`--record|--replay` are artifact-modality only (not `--stage routing|converge`, not `--report`).
+
+**Replay is not a fresh-judge.** Gate-rules text is embedded in the live prompt; recorded
+responses are frozen. Replay cannot test rules *effectiveness* — that stays live and billable.
+What it can do: hard-fail when `_eval_gate_rules_sha` ≠ the recorded hash (`fixtures stale —
+re-record live per ADR re-baseline rule`). Replay verdicts **never count toward the eval floor**.
+
+**Refresh protocol:** edit both sides of a rules change, run a live `--record` batch (11 × `--n 3`
+= 33 judge calls + 1 probe; 9 heading-mapped fixtures bill 27 + probe today) on a host with
+real `timeout`/`gtimeout`, commit the stripped `eval/replay/` tree (verdict lines only — no
+`session_id` / `cwd` envelopes) **in the same change** as the `gate-rules.md` edit. No
+operator-recorded batch exists yet — the `eval-replay` CI job skip-with-notice until then;
+the recorded-sha staleness check is unchanged.
+
+**B1 escalation:** if hollow-done decoys that name no artifact/command recur in dogfood or
+live eval after the B1-S addendum lands, escalate to full structured lineage evidence. Replay
+verdicts never count toward that trigger.
+
 ## Running it
 
 ```
@@ -86,6 +173,8 @@ flow.sh eval --stage card              # only the card-gate fixtures
 flow.sh eval --fixture fcdb --n 1       # one fixture, one run (cheap smoke check)
 flow.sh eval --timeout 180              # override the per-call timeout (default 120s)
 flow.sh eval --report                   # OFFLINE: last complete batch's scorecard + drift
+flow.sh eval --record --n 3             # LIVE: write stripped replay fixtures (billable)
+flow.sh eval --replay --n 3             # KEYLESS: replay recorded transcripts
 ```
 
 Exit code: `0` = every evaluated fixture majority-matched its expected verdict (or a clean
@@ -146,9 +235,10 @@ yet (the same "measure, don't assume" discipline that gated this build in the fi
   platform: a signal arriving while the runner is blocked on a foreground judge call was not
   observed to preempt that call promptly. Cleanup between fixtures/calls fires reliably; a
   normal (uninterrupted) run always cleans up its temp files immediately.
-- **Small fixture corpus (seven)**: enough to prove the mechanism and give a real number, not
-  enough for statistical confidence across every stage/failure-mode combination. Widening the
-  corpus is a natural v1.x follow-up, not a v1 blocker.
+- **Small fixture corpus (eleven manifest rows, nine heading-mapped)**: enough to prove the
+  mechanism and give a real number, not enough for statistical confidence across every
+  stage/failure-mode combination. Widening the corpus is a natural v1.x follow-up, not a
+  v1 blocker.
 
 ## Failure modes and postmortem (v0.21)
 
@@ -174,8 +264,8 @@ window; the mechanism was never confirmed at the time (rate-limit vs hook conten
 4. **Circuit breaker.** The FIRST evaluated fixture coming back UNRELIABLE (`invalid_count*3 > n`)
    aborts the batch with a distinct nonzero exit code (2) and NO `done` trailer written — the
    junk batch is invisible to `--report`/drift, so it cannot poison the baseline. `--keep-going`
-   forces the full batch; document worst case (≤ N_fixtures × n × 2 + 1 probe ≈ 37 calls at
-   default 7 × 3).
+   forces the full batch; document worst case (≤ N_fixtures × n × 2 + 1 probe ≈ 55 calls at
+   default 9 heading-mapped × 3).
 
 ### Rate-limit visibility (advisory, best-effort)
 

package/skills/flow/references/gate-rules.md

@@ -182,6 +182,9 @@ evidence non-empty.
 - **Is `## Evidence` real world-state** — a clickable URL, real curl output, a DB row — and
   NOT "tests pass" / "code merged" / "deployed successfully"? Merge != shipped: the proof is
   the live surface changing, verified as a user.
+- **Does every `## Evidence` item name its artifact (path/URL) or the command that produced
+  it?** Plausible prose that names neither is still hollow even when the mechanical floor
+  passes (`ground-truth-gates.md` rule 8).
 - **If this card fixes a bug/regression**, the evidence includes the red→green proof that the
   new test was actually tied to the bug (`ground-truth-gates.md` → "Bug-fix cards"), not just a
   green run.

package/skills/flow/references/ground-truth-gates.md

@@ -40,6 +40,13 @@ and used only to add color, never to pass a gate.
 7. **Hand-edit `status: done` is not trusted for deps** until Evidence **and** Verify boxes
    pass the same floor (`ready` re-validates Evidence + unchecked Verify + `[FILL]`; graph
    executor mirrors).
+8. **Every done-evidence item names its artifact or command.** Each `## Evidence` item must
+   name the path/URL of the artifact or the command that produced it. Plausible prose that
+   names neither is hollow even when the mechanical multi-signal floor passes — the card
+   gate's semantic challenge catches it (`gate-rules.md` → Card gate). Old prose-only
+   evidence still passes `flow.sh check` (the floor is unchanged). **Escalate to full
+   structured lineage evidence (B1)** only if hollow-done decoys of this class recur in
+   dogfood or live eval after this addendum lands.
 
 ## Bug-fix cards: prove the test was tied to the bug
 When a card's job is fixing a bug/regression (not new behavior), a passing test is not yet

package/skills/flow/references/host-agnostic-parallel.md

@@ -0,0 +1,54 @@
+# Host-agnostic parallel occupancy
+
+Flow requires **no named multiplexer**. Parallel cards are a ready-gate +
+worktrees + host-owned placement + world-state fan-in. Absence of Herdr, tmux,
+in-process `Task`, or any other host **never fails a gate** and never changes
+`flow.sh` exit.
+
+Herdr and tmux appear below only as **examples, never as a dependency** or a
+first-class adapter.
+
+## Degrade ladder
+
+| Rung | Primitive already in the process | Who binds occupants | Who waits |
+|---|---|---|---|
+| **0** | In-process subagents / `Task` | Hosting agent; cwd = the card's worktree | Host `Task` join |
+| **1** | Operator extra terminals / tabs | Human pastes the print-enter block | Human |
+| **2** | Process is **already inside** a mux (`HERDR_ENV=1` / `TMUX` set) | That mux's **own** skill/CLI; flow does not wrap or detect it | That mux's own wait |
+| **3** | None of the above, or `/flow ready` overlap | Serial: one card | Hosting agent, one at a time |
+
+Rung 2 is opt-in by the mux's own environment injection, never by `PATH`.
+Inside-mux probe is the mux's own env (`HERDR_ENV=1`, `TMUX`), never
+`command -v herdr` from outside (a CLI can talk to a same-uid socket without
+`HERDR_ENV`). Absence of rungs 0–2 is the default path, not a degrade footnote.
+
+## Gate parity
+
+Host `idle` / `done` / `blocked` is **not a card pass**. `flow.sh check` still
+judges, and it must run **in the card's worktree** (parent-tree check of main
+is a false fail/pass). Screen output is not evidence.
+
+Keep the four "blocked" senses distinct:
+
+| Sense | Meaning | Home |
+|---|---|---|
+| **host-blocked** | mux/pane approval chrome or occupant stuck | the host |
+| **subagent-BLOCKED** | scoped subagent status protocol | `agent-detection.md` |
+| **ready-blocked** | deps unmet or allowed-files overlap | `flow.sh ready` |
+| **Tier-C security halt** | security-class exposure; operator DEBT | `auto-run.md` |
+
+Mixing them auto-answers a payments card or auto-halts a yes/no prompt.
+
+## File-is-the-wait
+
+The **HOST waits** (Task join / human / the mux's own wait). `flow.sh` **never waits on or polls** another agent. Fan-in is world-state: re-invoke `check` in
+the card worktree after the host's wait returns.
+
+## Forbidden (ADR-0001; not a nit)
+
+`flow.sh` must not exec host control CLIs (`herdr agent start`, `herdr agent wait`, `herdr agent prompt`, `herdr server stop`, `tmux send-keys`, and equivalents).
+Forbidden by name: `mux-up`, `mux-run-wave`, `mux-proxy`. No screen output as
+evidence. No hook install into `~/.claude` or `~/.omp`. No long-lived socket subscribe (`events.subscribe`). `flow.sh` never spawns agents; placement is print-enter or the host's own Task/mux.
+
+Own-runtime / own-PTY / own-wait is a successor ADR plus a separate product,
+not a card in this skill.

package/skills/flow/runner/flow.sh

@@ -69,6 +69,8 @@ HARNESS_PY="$SCRIPT_DIR/../harness/flow_harness.py"
 # so an overridden manifest can only ever point at real shipped fixtures under the real EVAL_DIR.
 EVAL_DIR="$SCRIPT_DIR/../eval"
 EVAL_MANIFEST="${FLOW_EVAL_MANIFEST:-$EVAL_DIR/manifest.tsv}"
+# FLOW_EVAL_REPLAY_DIR is a TEST-ONLY override (synthetic harness-built transcripts).
+EVAL_REPLAY_DIR="${FLOW_EVAL_REPLAY_DIR:-$EVAL_DIR/replay}"
 GATE_RULES_FILE="$SCRIPT_DIR/../references/gate-rules.md"
 
 # Routing eval (v0.22 concierge routing judge - a SEPARATE modality from the artifact-vs-
@@ -2300,6 +2302,14 @@ cmd_doctor() {
   command -v cargo >/dev/null 2>&1 && echo "  cargo:     ok (optional Rust harness power-path)" || true
   [ -d "$TEMPLATE_DIR" ] && echo "  templates: ok" || { echo "  templates: MISSING ($TEMPLATE_DIR)"; ok=0; }
   [ -f "$HARNESS_PY" ] && echo "  harness:   present ($HARNESS_PY)" || echo "  harness:   absent (durable layer off)"
+  if command -v timeout >/dev/null 2>&1 || command -v gtimeout >/dev/null 2>&1; then
+    echo "  timeout:   full (timeout|gtimeout present)"
+  else
+    case "$(uname -s 2>/dev/null)" in
+      Darwin) echo "  timeout:   absent (no timeout/gtimeout; live eval REFUSED)" ;;
+      *)      echo "  timeout:   partial (watchdog fallback; live eval not GNU-bounded)" ;;
+    esac
+  fi
   echo
   if [ "$ok" -eq 1 ]; then
     echo "READY. Gate engine works$([ -n "$py" ] && echo '; durable layer on.' || echo '; durable layer off (no python).')"
@@ -3197,6 +3207,25 @@ _eval_engine_run() { # $1=promptfile $2=timeout-seconds -> stdout=raw json; retu
 # command string above. Empirical: adding a `2> '$errfile'` inside the timed cmd breaks the
 # watchdog-fallback path in `_run_with_timeout` on the timeout-less-PATH lane (macOS DEBT lane).
 # Outer-scope redirection is exactly the same capture at zero cost to the timeout contract.
+# Opt-in isolated cwd for live eval (Approach D). Unset = today's cwd (byte-identical
+# call path). Set but not a directory = fail loud. Isolation is cd+env around existing
+# probe/engine calls — never argv, never a second engine. CLAUDE_CODE_SAFE_MODE=1 is
+# exported ONLY in the isolated subshell (official Claude env; keeps OAuth; blast radius
+# is the judge child). Do not invent a flow alias; do not set HOME or CLAUDE_CONFIG_DIR.
+_eval_isolated_guard() {
+  [ -z "${FLOW_EVAL_ISOLATED_CWD:-}" ] && return 0
+  [ -d "$FLOW_EVAL_ISOLATED_CWD" ] && return 0
+  echo "FAIL: FLOW_EVAL_ISOLATED_CWD is set but is not a directory: $FLOW_EVAL_ISOLATED_CWD"
+  return 1
+}
+_eval_isolated_run() {
+  if [ -n "${FLOW_EVAL_ISOLATED_CWD:-}" ]; then
+    ( cd "$FLOW_EVAL_ISOLATED_CWD" && export CLAUDE_CODE_SAFE_MODE=1 && "$@" )
+  else
+    "$@"
+  fi
+}
+
 
 # Build the judge prompt for one fixture. Returns 1 (writes nothing usable) if the gate-rules.md
 # section extraction came back empty.
@@ -3289,6 +3318,13 @@ _eval_gate_rules_sha() {
   tr -d '\r' < "$GATE_RULES_FILE" | cksum | awk '{print $1}'
 }
 
+# CRLF-normalized assembler-output hash (same recipe as _eval_gate_rules_sha). Covers
+# prompt-file bytes only — not host CLAUDE.md. $1=prompt file.
+_eval_prompt_sha() {
+  [ -f "$1" ] || { printf 'unknown'; return; }
+  tr -d '\r' < "$1" | cksum | awk '{print $1}'
+}
+
 # `claude --version` is the CLI version (e.g. "2.1.201 (Claude Code)"), NOT a model id - kept
 # as its own axis distinct from `_eval_parse_model` (red-team finding #4: 3 reviewers
 # independently confirmed conflating the two is wrong). `< /dev/null`: this and every other
@@ -3302,6 +3338,48 @@ _eval_cli_version() {
   [ -n "$v" ] && printf '%s' "$v" || printf 'unknown'
 }
 
+# Replay/record helpers. Do not live inside _eval_engine_run. Meta is key=value, one per line.
+_eval_replay_meta_get() { # $1=key -> value (empty + return 1 if missing)
+  local key="$1" line
+  [ -f "$EVAL_REPLAY_DIR/meta" ] || return 1
+  while IFS= read -r line || [ -n "$line" ]; do
+    line="${line%$'\r'}"
+    case "$line" in
+      "${key}="*) printf '%s' "${line#${key}=}"; return 0 ;;
+    esac
+  done < "$EVAL_REPLAY_DIR/meta"
+  return 1
+}
+
+_eval_replay_write_meta() { # $1=nonce $2=gate_rules_sha $3=model $4=n [$5=prompt_sha.<fid>= lines]
+  mkdir -p "$EVAL_REPLAY_DIR" || return 1
+  printf 'nonce=%s\ngate_rules_sha=%s\nmodel=%s\nn=%s\n' "$1" "$2" "$3" "$4" > "$EVAL_REPLAY_DIR/meta" || return 1
+  [ -n "${5:-}" ] && printf '%s' "$5" >> "$EVAL_REPLAY_DIR/meta"
+}
+
+# Persist one stripped verdict line only — never a JSON envelope (session_id/cwd stay out).
+_eval_fid_safe() { # $1=fid -> filename-safe token (no path separators)
+  local s
+  s="$(printf '%s' "$1" | tr -c 'A-Za-z0-9' '-' | sed -E 's/-+/-/g; s/^-//; s/-$//')"
+  [ -n "$s" ] || s="_"
+  printf '%s' "$s"
+}
+
+_eval_record_vote() { # $1=fid $2=vote-i $3=nonce $4=FLAG|PASS|INVALID
+  local dest="$EVAL_REPLAY_DIR/$(_eval_fid_safe "$1")"
+  mkdir -p "$dest" || return 1
+  printf 'GATE-EVAL-%s: %s\n' "$3" "$4" > "$dest/$2.txt"
+}
+
+_eval_replay_vote() { # $1=fid $2=vote-i -> transcript on stdout; return 1 if missing
+  local f="$EVAL_REPLAY_DIR/$(_eval_fid_safe "$1")/$2.txt"
+  if [ ! -f "$f" ]; then
+    echo "eval --replay: missing fixture $1 vote $2 at $f" >&2
+    return 1
+  fi
+  cat "$f"
+}
+
 # Batch header/trailer: the completeness signal `--report`/drift filter on is "start present +
 # done present + n_written >= n_expected". Two paths lead to a MISSING trailer (correctly
 # incomplete): (a) an interrupted batch (INT/TERM trap exits before this line, per the eval
@@ -3323,17 +3401,18 @@ _eval_emit_batch_marker() { # $1=run_id $2=start|done $3=n_expected-or-n_written
 # cli_version/flow_version/gate_rules_sha are passed in (computed ONCE per batch by the caller,
 # not per fixture row) - they never change mid-batch, and recomputing per-row was both wasteful
 # (an extra subprocess per fixture) and the original vector for the stdin-consumption bug above.
-_eval_emit_result() { # $1..$14 as before + $15=retries $16=rate_limited (true|false)
+_eval_emit_result() { # $1..$14 as before + $15=retries $16=rate_limited $17=prompt_sha $18=timed_out
   local run_id="$1" fid="$2" stage="$3" expected="$4" verdict="$5" match="$6" flag="$7" pass="$8" invalid="$9" n="${10}" model="${11}" cliv="${12}" flowv="${13}" grsha="${14}"
-  local retries="${15:-0}" ratel="${16:-false}"
+  local retries="${15:-0}" ratel="${16:-false}" psha="${17:-}" timedout="${18:-false}"
   case "$retries" in ''|*[!0-9]*) retries=0 ;; esac
   case "$ratel"   in true|false) : ;; *) ratel=false ;; esac
+  case "$timedout" in true|false) : ;; *) timedout=false ;; esac
   mkdir -p "$LOG_DIR" 2>/dev/null || true
-  printf '{"ts":"%s","epoch_s":%s,"run_id":"%s","fixture":"%s","stage":"%s","expected":"%s","verdict":"%s","match":"%s","votes":{"flag":%s,"pass":%s,"invalid":%s},"n":%s,"cli_version":"%s","model":"%s","flow_version":"%s","gate_rules_sha":"%s","retries":%s,"rate_limited":%s}\n' \
+  printf '{"ts":"%s","epoch_s":%s,"run_id":"%s","fixture":"%s","stage":"%s","expected":"%s","verdict":"%s","match":"%s","votes":{"flag":%s,"pass":%s,"invalid":%s},"n":%s,"cli_version":"%s","model":"%s","flow_version":"%s","gate_rules_sha":"%s","retries":%s,"rate_limited":%s,"prompt_sha":"%s","timed_out":%s}\n' \
     "$(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || echo unknown)" "$(_now)" "$(_json_str "$run_id")" "$(_json_str "$fid")" \
     "$(_json_str "$stage")" "$(_json_str "$expected")" "$(_json_str "$verdict")" "$(_json_str "$match")" \
     "$flag" "$pass" "$invalid" "$n" "$(_json_str "$cliv")" "$(_json_str "$model")" \
-    "$(_json_str "$flowv")" "$(_json_str "$grsha")" "$retries" "$ratel" >> "$EVAL_RESULTS_FILE" 2>/dev/null || true
+    "$(_json_str "$flowv")" "$(_json_str "$grsha")" "$retries" "$ratel" "$(_json_str "$psha")" "$timedout" >> "$EVAL_RESULTS_FILE" 2>/dev/null || true
 }
 
 # Strip the noisy `system`/`init` envelope from a raw --output-format json line before persisting
@@ -3617,17 +3696,18 @@ _eval_routing_parse_action() {
   [ -n "$action" ] && printf '%s' "$action" || echo INVALID
 }
 
-_eval_routing_emit_result() { # $1=run_id $2=fid $3=expected $4=verdict $5=match $6..$9=votes-hit/miss/invalid/n $10=model $11=cliv $12=flowv $13=rulessha $14=retries $15=rate_limited
+_eval_routing_emit_result() { # $1=run_id $2=fid $3=expected $4=verdict $5=match $6..$9=votes $10=model $11=cliv $12=flowv $13=rulessha $14=retries $15=rate_limited $16=prompt_sha $17=timed_out
   local run_id="$1" fid="$2" expected="$3" verdict="$4" match="$5" hit="$6" miss="$7" invalid="$8" n="$9"
-  local model="${10}" cliv="${11}" flowv="${12}" rulessha="${13}" retries="${14:-0}" ratel="${15:-false}"
+  local model="${10}" cliv="${11}" flowv="${12}" rulessha="${13}" retries="${14:-0}" ratel="${15:-false}" psha="${16:-}" timedout="${17:-false}"
   case "$retries" in ''|*[!0-9]*) retries=0 ;; esac
   case "$ratel"   in true|false) : ;; *) ratel=false ;; esac
+  case "$timedout" in true|false) : ;; *) timedout=false ;; esac
   mkdir -p "$LOG_DIR" 2>/dev/null || true
-  printf '{"ts":"%s","epoch_s":%s,"run_id":"%s","fixture":"%s","expected":"%s","verdict":"%s","match":"%s","votes":{"hit":%s,"miss":%s,"invalid":%s},"n":%s,"cli_version":"%s","model":"%s","flow_version":"%s","rules_sha":"%s","retries":%s,"rate_limited":%s}\n' \
+  printf '{"ts":"%s","epoch_s":%s,"run_id":"%s","fixture":"%s","expected":"%s","verdict":"%s","match":"%s","votes":{"hit":%s,"miss":%s,"invalid":%s},"n":%s,"cli_version":"%s","model":"%s","flow_version":"%s","rules_sha":"%s","retries":%s,"rate_limited":%s,"prompt_sha":"%s","timed_out":%s}\n' \
     "$(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || echo unknown)" "$(_now)" "$(_json_str "$run_id")" "$(_json_str "$fid")" \
     "$(_json_str "$expected")" "$(_json_str "$verdict")" "$(_json_str "$match")" \
     "$hit" "$miss" "$invalid" "$n" "$(_json_str "$cliv")" "$(_json_str "$model")" \
-    "$(_json_str "$flowv")" "$(_json_str "$rulessha")" "$retries" "$ratel" >> "$EVAL_ROUTING_RESULTS_FILE" 2>/dev/null || true
+    "$(_json_str "$flowv")" "$(_json_str "$rulessha")" "$retries" "$ratel" "$(_json_str "$psha")" "$timedout" >> "$EVAL_ROUTING_RESULTS_FILE" 2>/dev/null || true
 }
 
 _eval_routing_complete_run_ids() {
@@ -3727,7 +3807,9 @@ function cmd_eval_routing { # same arg shape as cmd_eval, called only when --sta
     return 1
   fi
 
-  local probe; probe="$(_eval_probe)"
+  _eval_isolated_guard || return 1
+
+  local probe; probe="$(_eval_isolated_run _eval_probe)"
   case "$probe" in
     absent)
       echo "SKIP: 'claude' CLI not found on PATH - routing eval needs it to run the LLM judge. Zero calls made."
@@ -3795,14 +3877,18 @@ function cmd_eval_routing { # same arg shape as cmd_eval, called only when --sta
       continue
     fi
 
+    local psha
+    psha="$(_eval_prompt_sha "$promptfile")"
+
     total_evaluated=$((total_evaluated + 1))
-    local hit_count=0 miss_count=0 invalid_count=0 i=1 model="unknown" retries_sum=0 vote_rate_limited=false
+    local hit_count=0 miss_count=0 invalid_count=0 i=1 model="unknown" retries_sum=0 vote_rate_limited=false vote_timed_out=false
     while [ "$i" -le "$n" ]; do
       local raw rc v raw1="" rc1=0
-      raw="$(_eval_engine_run "$promptfile" "$timeout" 2>/dev/null)"; rc=$?
+      raw="$(_eval_isolated_run _eval_engine_run "$promptfile" "$timeout" 2>/dev/null)"; rc=$?
       raw1="$raw"; rc1="$rc"
       if [ "$rc" -eq 124 ]; then
         v=INVALID
+        vote_timed_out=true
       else
         v="$(_eval_routing_parse_action "$raw" "$nonce")"
         [ "$model" = "unknown" ] && model="$(_eval_parse_model "$raw")"
@@ -3814,9 +3900,9 @@ function cmd_eval_routing { # same arg shape as cmd_eval, called only when --sta
           echo "  $fid: retrying vote $i after ${backoff}s (parse-INVALID on attempt 1)"
           sleep "$backoff" 2>/dev/null || true
         fi
-        raw="$(_eval_engine_run "$promptfile" "$timeout" 2>/dev/null)"; rc=$?
+        raw="$(_eval_isolated_run _eval_engine_run "$promptfile" "$timeout" 2>/dev/null)"; rc=$?
         retries_sum=$((retries_sum + 1))
-        if [ "$rc" -eq 124 ]; then v=INVALID; else v="$(_eval_routing_parse_action "$raw" "$nonce")"; fi
+        if [ "$rc" -eq 124 ]; then v=INVALID; vote_timed_out=true; else v="$(_eval_routing_parse_action "$raw" "$nonce")"; fi
         [ "$model" = "unknown" ] && [ "$rc" -ne 124 ] && model="$(_eval_parse_model "$raw")"
         local rl2; rl2="$(_eval_parse_rate_limited "$raw")"
         [ "$rl2" = "true" ] && vote_rate_limited=true
@@ -3854,7 +3940,7 @@ function cmd_eval_routing { # same arg shape as cmd_eval, called only when --sta
       echo "  $fid: MISS - expected '$fexpected' (hit=$hit_count miss=$miss_count invalid=$invalid_count)"
     fi
 
-    _eval_routing_emit_result "$nonce" "$fid" "$fexpected" "$verdict" "$match" "$hit_count" "$miss_count" "$invalid_count" "$n" "$model" "$batch_cliv" "$batch_flowv" "$batch_rulessha" "$retries_sum" "$vote_rate_limited"
+    _eval_routing_emit_result "$nonce" "$fid" "$fexpected" "$verdict" "$match" "$hit_count" "$miss_count" "$invalid_count" "$n" "$model" "$batch_cliv" "$batch_flowv" "$batch_rulessha" "$retries_sum" "$vote_rate_limited" "$psha" "$vote_timed_out"
     n_written=$((n_written + 1))
 
     if [ "$total_evaluated" -eq 1 ] && [ "$verdict" = "UNRELIABLE" ] && [ "$keep_going" -eq 0 ]; then
@@ -3962,15 +4048,16 @@ _eval_converge_parse_verdict() { # $1=raw $2=nonce -> GAP|CONVERGED|INVALID
 
 _eval_converge_emit_result() { # same field shape as _eval_routing_emit_result
   local run_id="$1" fid="$2" expected="$3" verdict="$4" match="$5" hit="$6" miss="$7" invalid="$8" n="$9"
-  local model="${10}" cliv="${11}" flowv="${12}" rulessha="${13}" retries="${14:-0}" ratel="${15:-false}"
+  local model="${10}" cliv="${11}" flowv="${12}" rulessha="${13}" retries="${14:-0}" ratel="${15:-false}" psha="${16:-}" timedout="${17:-false}"
   case "$retries" in ''|*[!0-9]*) retries=0 ;; esac
   case "$ratel"   in true|false) : ;; *) ratel=false ;; esac
+  case "$timedout" in true|false) : ;; *) timedout=false ;; esac
   mkdir -p "$LOG_DIR" 2>/dev/null || true
-  printf '{"ts":"%s","epoch_s":%s,"run_id":"%s","fixture":"%s","expected":"%s","verdict":"%s","match":"%s","votes":{"hit":%s,"miss":%s,"invalid":%s},"n":%s,"cli_version":"%s","model":"%s","flow_version":"%s","rules_sha":"%s","retries":%s,"rate_limited":%s}\n' \
+  printf '{"ts":"%s","epoch_s":%s,"run_id":"%s","fixture":"%s","expected":"%s","verdict":"%s","match":"%s","votes":{"hit":%s,"miss":%s,"invalid":%s},"n":%s,"cli_version":"%s","model":"%s","flow_version":"%s","rules_sha":"%s","retries":%s,"rate_limited":%s,"prompt_sha":"%s","timed_out":%s}\n' \
     "$(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || echo unknown)" "$(_now)" "$(_json_str "$run_id")" "$(_json_str "$fid")" \
     "$(_json_str "$expected")" "$(_json_str "$verdict")" "$(_json_str "$match")" \
     "$hit" "$miss" "$invalid" "$n" "$(_json_str "$cliv")" "$(_json_str "$model")" \
-    "$(_json_str "$flowv")" "$(_json_str "$rulessha")" "$retries" "$ratel" >> "$EVAL_CONVERGE_RESULTS_FILE" 2>/dev/null || true
+    "$(_json_str "$flowv")" "$(_json_str "$rulessha")" "$retries" "$ratel" "$(_json_str "$psha")" "$timedout" >> "$EVAL_CONVERGE_RESULTS_FILE" 2>/dev/null || true
 }
 
 _eval_converge_emit_batch_marker() { # $1=run_id $2=start|done $3=n
@@ -4032,7 +4119,9 @@ function cmd_eval_converge { # same arg shape as cmd_eval, called only when --st
     return 1
   fi
 
-  local probe; probe="$(_eval_probe)"
+  _eval_isolated_guard || return 1
+
+  local probe; probe="$(_eval_isolated_run _eval_probe)"
   case "$probe" in
     absent) echo "SKIP: 'claude' CLI not found on PATH - converge eval needs it to run the LLM judge. Zero calls made."; return 0 ;;
     fail)   echo "SKIP: 'claude' CLI present but the sentinel probe did not come back clean (one minimal probe call was made). Retry once 'claude -p' runs headless."; return 0 ;;
@@ -4080,17 +4169,20 @@ function cmd_eval_converge { # same arg shape as cmd_eval, called only when --st
       echo "  $fid: FAIL - could not build converge prompt (converge.md/repo-dir/challenge missing)"; total_miss=$((total_miss + 1)); rm -rf "$rundir" 2>/dev/null; continue
     fi
 
+    local psha
+    psha="$(_eval_prompt_sha "$promptfile")"
+
     total_evaluated=$((total_evaluated + 1))
-    local hit_count=0 miss_count=0 invalid_count=0 i=1 model="unknown" retries_sum=0 vote_rate_limited=false
+    local hit_count=0 miss_count=0 invalid_count=0 i=1 model="unknown" retries_sum=0 vote_rate_limited=false vote_timed_out=false
     while [ "$i" -le "$n" ]; do
       local raw rc v raw1="" rc1=0
-      raw="$(_eval_engine_run "$promptfile" "$timeout" 2>/dev/null)"; rc=$?; raw1="$raw"; rc1="$rc"
-      if [ "$rc" -eq 124 ]; then v=INVALID; else v="$(_eval_converge_parse_verdict "$raw" "$nonce")"; [ "$model" = "unknown" ] && model="$(_eval_parse_model "$raw")"; fi
+      raw="$(_eval_isolated_run _eval_engine_run "$promptfile" "$timeout" 2>/dev/null)"; rc=$?; raw1="$raw"; rc1="$rc"
+      if [ "$rc" -eq 124 ]; then v=INVALID; vote_timed_out=true; else v="$(_eval_converge_parse_verdict "$raw" "$nonce")"; [ "$model" = "unknown" ] && model="$(_eval_parse_model "$raw")"; fi
       local rl1; rl1="$(_eval_parse_rate_limited "$raw1")"; [ "$rl1" = "true" ] && vote_rate_limited=true
       if [ "$v" = "INVALID" ] && [ "$rl1" != "true" ] && [ "$rc1" -ne 124 ]; then
         if [ "$backoff" -gt 0 ]; then echo "  $fid: retrying vote $i after ${backoff}s (parse-INVALID on attempt 1)"; sleep "$backoff" 2>/dev/null || true; fi
-        raw="$(_eval_engine_run "$promptfile" "$timeout" 2>/dev/null)"; rc=$?; retries_sum=$((retries_sum + 1))
-        if [ "$rc" -eq 124 ]; then v=INVALID; else v="$(_eval_converge_parse_verdict "$raw" "$nonce")"; fi
+        raw="$(_eval_isolated_run _eval_engine_run "$promptfile" "$timeout" 2>/dev/null)"; rc=$?; retries_sum=$((retries_sum + 1))
+        if [ "$rc" -eq 124 ]; then v=INVALID; vote_timed_out=true; else v="$(_eval_converge_parse_verdict "$raw" "$nonce")"; fi
         [ "$model" = "unknown" ] && [ "$rc" -ne 124 ] && model="$(_eval_parse_model "$raw")"
         local rl2; rl2="$(_eval_parse_rate_limited "$raw")"; [ "$rl2" = "true" ] && vote_rate_limited=true
       fi
@@ -4115,7 +4207,7 @@ function cmd_eval_converge { # same arg shape as cmd_eval, called only when --st
       total_miss=$((total_miss + 1)); echo "  $fid: MISS - expected '$fexpected' (hit=$hit_count miss=$miss_count invalid=$invalid_count)"
     fi
 
-    _eval_converge_emit_result "$nonce" "$fid" "$fexpected" "$verdict" "$match" "$hit_count" "$miss_count" "$invalid_count" "$n" "$model" "$batch_cliv" "$batch_flowv" "$batch_rulessha" "$retries_sum" "$vote_rate_limited"
+    _eval_converge_emit_result "$nonce" "$fid" "$fexpected" "$verdict" "$match" "$hit_count" "$miss_count" "$invalid_count" "$n" "$model" "$batch_cliv" "$batch_flowv" "$batch_rulessha" "$retries_sum" "$vote_rate_limited" "$psha" "$vote_timed_out"
     n_written=$((n_written + 1))
 
     if [ "$total_evaluated" -eq 1 ] && [ "$verdict" = "UNRELIABLE" ] && [ "$keep_going" -eq 0 ]; then
@@ -4138,6 +4230,30 @@ function cmd_eval_converge { # same arg shape as cmd_eval, called only when --st
   return 1
 }
 
+# Live-eval entry guard (macOS DEBT). Refuse artifact eval on darwin when no real
+# timeout/gtimeout can bound a stuck claude call. Replay (Phase 7 sets replay_mode=1)
+# never hits this. --report returns before the call site. Do not move this into
+# _eval_engine_run or _run_with_timeout.
+_eval_guard_unbounded_darwin() { # $1=replay_mode (0/1); return 1 = refused
+  local replay_mode="${1:-0}"
+  [ "$replay_mode" -eq 0 ] || return 0
+  [ "${FLOW_EVAL_UNBOUNDED:-}" = "1" ] && return 0
+  local darwin=0
+  if [ "${FLOW_EVAL_FORCE_DARWIN:-}" = "1" ]; then
+    darwin=1
+  else
+    case "$(uname -s 2>/dev/null)" in Darwin) darwin=1 ;; esac
+  fi
+  [ "$darwin" -eq 1 ] || return 0
+  if command -v timeout >/dev/null 2>&1 || command -v gtimeout >/dev/null 2>&1; then
+    return 0
+  fi
+  echo "REFUSED: live eval on macOS without timeout/gtimeout cannot bound a stuck claude call."
+  echo "  Unbounded-billing risk: a hung judge can run past --timeout (DEBT.md)."
+  echo "  Install GNU coreutils (gtimeout) or export FLOW_EVAL_UNBOUNDED=1 to accept that risk."
+  return 1
+}
+
 # NOTE: defined with the `function name { }` form (no parens) rather than this file's usual
 # `name() { }` style, solely so the literal 4-byte substring the shipped verb name is built
 # from never appears immediately followed by '(' in the source - a blind text-pattern security
@@ -4145,7 +4261,7 @@ function cmd_eval_converge { # same arg shape as cmd_eval, called only when --st
 # -positives on that exact byte sequence regardless of language. Purely a spelling dodge for a
 # generic scanner; behavior is 100% identical to every other function in this file.
 function cmd_eval {
-  local stage_filter="" fixture_filter="" n=3 timeout=120 report_mode=0 keep_going=0
+  local stage_filter="" fixture_filter="" n=3 timeout=120 report_mode=0 keep_going=0 replay_mode=0 record_mode=0
   while [ $# -gt 0 ]; do
     case "$1" in
       --stage)      shift; stage_filter="${1:-}" ;;
@@ -4153,8 +4269,10 @@ function cmd_eval {
       --n)          shift; n="${1:-3}" ;;
       --timeout)    shift; timeout="${1:-120}" ;;
       --report)     report_mode=1 ;;
+      --record)     record_mode=1 ;;
+      --replay)     replay_mode=1 ;;
       --keep-going) keep_going=1 ;;
-      *) echo "usage: /flow eval [--stage 01|02|05|card|routing|converge] [--fixture <id>] [--n 3] [--timeout <seconds>] [--keep-going] [--report]"; return 1 ;;
+      *) echo "usage: /flow eval [--stage 01|02|05|card|routing|converge] [--fixture <id>] [--n 3] [--timeout <seconds>] [--keep-going] [--report] [--record|--replay]"; return 1 ;;
     esac
     shift 2>/dev/null || true
   done
@@ -4167,6 +4285,26 @@ function cmd_eval {
   local backoff="${FLOW_EVAL_RETRY_BACKOFF:-5}"
   case "$backoff" in ''|*[!0-9]*) backoff=5 ;; esac
 
+  # Reject window: --record|--replay is artifact-modality only. Must run BEFORE routing/
+  # converge dispatch and BEFORE the --report early-return. --record is LIVE (replay_mode
+  # stays 0) so the Phase 6 darwin guard still fires.
+  if [ "$record_mode" -eq 1 ] && [ "$replay_mode" -eq 1 ]; then
+    echo "usage: /flow eval --record and --replay are mutually exclusive"
+    return 1
+  fi
+  if [ "$record_mode" -eq 1 ] || [ "$replay_mode" -eq 1 ]; then
+    case "$stage_filter" in
+      routing|converge)
+        echo "usage: /flow eval --record|--replay is artifact-modality only (not --stage $stage_filter)"
+        return 1
+        ;;
+    esac
+    if [ "$report_mode" -eq 1 ]; then
+      echo "usage: /flow eval --record|--replay cannot combine with --report"
+      return 1
+    fi
+  fi
+
   # v0.22: routing is a SEPARATE judge modality (own manifest/prompt/verdict/results-file/
   # scorecard) - delegate entirely and return, before any of the artifact-eval logic below
   # (which assumes gate-rules.md stage sections and FLAG/PASS verdicts) ever runs.
@@ -4200,22 +4338,56 @@ function cmd_eval {
     return 1
   fi
 
-  local probe; probe="$(_eval_probe)"
-  case "$probe" in
-    absent)
-      echo "SKIP: 'claude' CLI not found on PATH - eval needs it to run the LLM judge. Zero calls made."
-      return 0 ;;
-    fail)
-      echo "SKIP: 'claude' CLI is present but the sentinel probe did not come back clean (one minimal"
-      echo "  billable probe call was made). Confirm 'claude -p' runs headless on this machine, then retry."
-      return 0 ;;
-  esac
+  # Live-eval entry. replay_mode=1 self-skips inside the guard; --record leaves
+  # replay_mode=0 so refuse-by-default still fires. Do not wrap this call again.
+  if ! _eval_guard_unbounded_darwin "$replay_mode"; then
+    return 1
+  fi
 
-  local nonce; nonce="$(_eval_nonce)"
-  local total_mismatch=0 total_unreliable=0 total_evaluated=0 rundir="" n_written=0 aborted=0
+  local nonce="" total_mismatch=0 total_unreliable=0 total_evaluated=0 rundir="" n_written=0 aborted=0
   # Computed ONCE per batch, not per fixture row - see _eval_emit_result's comment.
-  local batch_cliv batch_flowv batch_grsha
-  batch_cliv="$(_eval_cli_version)"; batch_flowv="$(_flow_version)"; batch_grsha="$(_eval_gate_rules_sha)"
+  local batch_cliv="" batch_flowv="" batch_grsha="" prompt_sha_acc="" prompt_sha_enforced=0
+  if [ "$replay_mode" -eq 1 ]; then
+    # Replay wrap: skip probe SKIP-exit and _eval_cli_version only. Still compute
+    # batch_grsha (staleness hard-fail) and _flow_version. Nonce from fixture, never _eval_nonce.
+    if [ ! -f "$EVAL_REPLAY_DIR/meta" ]; then
+      echo "eval --replay: missing replay fixtures at $EVAL_REPLAY_DIR (no meta). Never SKIP."
+      return 1
+    fi
+    nonce="$(_eval_replay_meta_get nonce)" || nonce=""
+    if [ -z "$nonce" ]; then
+      echo "eval --replay: meta missing nonce. Never SKIP."
+      return 1
+    fi
+    batch_grsha="$(_eval_gate_rules_sha)"
+    batch_flowv="$(_flow_version)"
+    batch_cliv="replay"
+    local rec_sha
+    rec_sha="$(_eval_replay_meta_get gate_rules_sha)" || rec_sha=""
+    if [ "$rec_sha" != "$batch_grsha" ]; then
+      echo "eval --replay: fixtures stale — gate-rules changed; re-record live per ADR re-baseline rule"
+      echo "  recorded=$rec_sha current=$batch_grsha"
+      return 1
+    fi
+    if grep -q '^prompt_sha\.' "$EVAL_REPLAY_DIR/meta" 2>/dev/null; then
+      prompt_sha_enforced=1
+    fi
+    echo "replay: keyless artifact batch (nonce from fixture, zero live calls)"
+  else
+    _eval_isolated_guard || return 1
+    local probe; probe="$(_eval_isolated_run _eval_probe)"
+    case "$probe" in
+      absent)
+        echo "SKIP: 'claude' CLI not found on PATH - eval needs it to run the LLM judge. Zero calls made."
+        return 0 ;;
+      fail)
+        echo "SKIP: 'claude' CLI is present but the sentinel probe did not come back clean (one minimal"
+        echo "  billable probe call was made). Confirm 'claude -p' runs headless on this machine, then retry."
+        return 0 ;;
+    esac
+    nonce="$(_eval_nonce)"
+    batch_cliv="$(_eval_cli_version)"; batch_flowv="$(_flow_version)"; batch_grsha="$(_eval_gate_rules_sha)"
+  fi
   echo "eval: batch $nonce (N=$n per fixture, timeout=${timeout}s)"
 
   # Ensure .flow/ (which now hosts eval-raw/ postmortem dumps) is git-ignored on any project
@@ -4246,7 +4418,9 @@ function cmd_eval {
     }
     END { print c + 0 }
   ' "$EVAL_MANIFEST")"
-  _eval_emit_batch_marker "$nonce" start "$n_expected"
+  if [ "$replay_mode" -eq 0 ]; then
+    _eval_emit_batch_marker "$nonce" start "$n_expected"
+  fi
 
   # Scoped INT/TERM trap: the sole EXIT trap (_log_on_exit -> _cleanup_tds) was found NOT to
   # fire reliably while blocked on a foreground `_run_with_timeout` child (verified: a signal
@@ -4293,29 +4467,63 @@ function cmd_eval {
 
     local promptfile="$rundir/prompt.txt"
     if ! _eval_build_prompt "$promptfile" "$fstage_short" "$artifact_path" "$nonce"; then
+      if [ "$replay_mode" -eq 1 ]; then
+        echo "  $fid: SKIP - no heading-mapped section (artifact-replay scope is 01|02|card)"
+        rm -rf "$rundir" 2>/dev/null
+        continue
+      fi
       echo "  $fid: FAIL - gate-rules.md section for stage '$fstage' extracted EMPTY (heading map or file drift) - aborted before any billable call"
       total_mismatch=$((total_mismatch + 1))
       rm -rf "$rundir" 2>/dev/null
       continue
     fi
 
+    local psha
+    psha="$(_eval_prompt_sha "$promptfile")"
+    if [ "$replay_mode" -eq 1 ] && [ "$prompt_sha_enforced" -eq 1 ]; then
+      local rec_psha
+      rec_psha="$(_eval_replay_meta_get "prompt_sha.$fid")" || rec_psha=""
+      if [ -z "$rec_psha" ] || [ "$rec_psha" != "$psha" ]; then
+        echo "eval --replay: fixtures stale — prompt assembly changed; re-record live per ADR re-baseline rule"
+        echo "  recorded=$rec_psha current=$psha fixture=$fid"
+        rm -rf "$rundir" 2>/dev/null
+        trap - INT TERM
+        return 1
+      fi
+    fi
+    if [ "$record_mode" -eq 1 ]; then
+      prompt_sha_acc="${prompt_sha_acc}prompt_sha.${fid}=${psha}"$'\n'
+    fi
+
     total_evaluated=$((total_evaluated + 1))
-    local flag_count=0 pass_count=0 invalid_count=0 i=1 model="unknown" retries_sum=0 vote_rate_limited=false
+    local flag_count=0 pass_count=0 invalid_count=0 i=1 model="unknown" retries_sum=0 vote_rate_limited=false vote_timed_out=false
     # Filename-safe fixture id for raw-capture paths - manifest fid is only tr -d '\r'-cleaned
     # (the v1 trust-boundary is READ-side only, but we are now WRITING keyed by it), so a
     # hand-edited or FLOW_EVAL_MANIFEST-overridden manifest cannot traverse out of eval-raw/.
     local fid_safe; fid_safe="$(printf '%s' "$fid" | tr -c 'A-Za-z0-9' '-' | sed -E 's/-+/-/g; s/^-//; s/-$//')"
     [ -z "$fid_safe" ] && fid_safe="_"
+    if [ "$replay_mode" -eq 0 ]; then
+      local rawdir_prompt="$LOG_DIR/eval-raw/$nonce"
+      if mkdir -p "$rawdir_prompt" 2>/dev/null; then
+        cp "$promptfile" "$rawdir_prompt/${fid_safe}.prompt" 2>/dev/null || true
+      fi
+    fi
     while [ "$i" -le "$n" ]; do
       local raw rc v raw1="" rc1=0 err1="" err2=""
       # Attempt 1 - stderr captured at the OUTER redirection so it never enters the sh -c
       # command string _eval_engine_run passes to _run_with_timeout (that broke the watchdog
       # fallback on the timeout-less-PATH lane - see engine-run's note).
       err1="$rundir/v${i}-a1.err"
-      raw="$(_eval_engine_run "$promptfile" "$timeout" 2>"$err1")"; rc=$?
+      if [ "$replay_mode" -eq 1 ]; then
+        raw="$(_eval_replay_vote "$fid" "$i")" || { rm -rf "$rundir" 2>/dev/null; trap - INT TERM; return 1; }
+        rc=0
+      else
+        raw="$(_eval_isolated_run _eval_engine_run "$promptfile" "$timeout" 2>"$err1")"; rc=$?
+      fi
       raw1="$raw"; rc1="$rc"
       if [ "$rc" -eq 124 ]; then
         v=INVALID
+        vote_timed_out=true
       else
         v="$(_eval_parse_verdict "$raw" "$nonce")"
         [ "$model" = "unknown" ] && model="$(_eval_parse_model "$raw")"
@@ -4332,7 +4540,7 @@ function cmd_eval {
       # _run_with_timeout is documented not to bound a stuck call (DEBT.md), a retry here just
       # waits another full stuck-call duration - test E on the 3-OS CI matrix reproduces this at
       # ~66s (2x ~30s stuck calls + backoff) despite --timeout 3.
-      if [ "$v" = "INVALID" ] && [ "$rl1" != "true" ] && [ "$rc1" -ne 124 ]; then
+      if [ "$replay_mode" -eq 0 ] && [ "$v" = "INVALID" ] && [ "$rl1" != "true" ] && [ "$rc1" -ne 124 ]; then
         # Backoff then retry - env-injectable so tests can zero it; skipped when rc=124 (timeout
         # was infra, retry would timeout again) or when rate-limited (see above).
         if [ "$backoff" -gt 0 ]; then
@@ -4342,9 +4550,14 @@ function cmd_eval {
           echo "  $fid: retrying vote $i (parse-INVALID on attempt 1)"
         fi
         err2="$rundir/v${i}-a2.err"
-        raw="$(_eval_engine_run "$promptfile" "$timeout" 2>"$err2")"; rc=$?
+        if [ "$replay_mode" -eq 1 ]; then
+          raw="$(_eval_replay_vote "$fid" "$i")" || { rm -rf "$rundir" 2>/dev/null; trap - INT TERM; return 1; }
+          rc=0
+        else
+          raw="$(_eval_isolated_run _eval_engine_run "$promptfile" "$timeout" 2>"$err2")"; rc=$?
+        fi
         retries_sum=$((retries_sum + 1))
-        if [ "$rc" -eq 124 ]; then v=INVALID; else v="$(_eval_parse_verdict "$raw" "$nonce")"; fi
+        if [ "$rc" -eq 124 ]; then v=INVALID; vote_timed_out=true; else v="$(_eval_parse_verdict "$raw" "$nonce")"; fi
         [ "$model" = "unknown" ] && [ "$rc" -ne 124 ] && model="$(_eval_parse_model "$raw")"
         local rl2; rl2="$(_eval_parse_rate_limited "$raw")"
         [ "$rl2" = "true" ] && vote_rate_limited=true
@@ -4385,6 +4598,9 @@ function cmd_eval {
         PASS) pass_count=$((pass_count + 1)) ;;
         *)    invalid_count=$((invalid_count + 1)) ;;
       esac
+      if [ "$record_mode" -eq 1 ]; then
+        _eval_record_vote "$fid" "$i" "$nonce" "$v"
+      fi
       i=$((i + 1))
     done
     rm -rf "$rundir" 2>/dev/null
@@ -4415,7 +4631,9 @@ function cmd_eval {
       echo "  $fid ($fstage): $verdict - MISMATCH, expected $fexpected (flag=$flag_count pass=$pass_count invalid=$invalid_count)"
     fi
 
-    _eval_emit_result "$nonce" "$fid" "$fstage" "$fexpected" "$verdict" "$match" "$flag_count" "$pass_count" "$invalid_count" "$n" "$model" "$batch_cliv" "$batch_flowv" "$batch_grsha" "$retries_sum" "$vote_rate_limited"
+    if [ "$replay_mode" -eq 0 ]; then
+      _eval_emit_result "$nonce" "$fid" "$fstage" "$fexpected" "$verdict" "$match" "$flag_count" "$pass_count" "$invalid_count" "$n" "$model" "$batch_cliv" "$batch_flowv" "$batch_grsha" "$retries_sum" "$vote_rate_limited" "$psha" "$vote_timed_out"
+    fi
     n_written=$((n_written + 1))
 
     # Circuit breaker: catches the 260710-class INVALID storm early. Trip when the FIRST
@@ -4442,9 +4660,12 @@ function cmd_eval {
   # SKIPS the trailer so an early-broken batch never satisfies --report's completeness check
   # (n_written>=n_expected AND trailer present), even on a --fixture-filtered run where
   # n_written could accidentally equal the filtered n_expected of 1.
-  if [ "$aborted" -eq 0 ]; then
+  if [ "$aborted" -eq 0 ] && [ "$replay_mode" -eq 0 ]; then
     _eval_emit_batch_marker "$nonce" done "$n_written"
   fi
+  if [ "$record_mode" -eq 1 ] && [ "$aborted" -eq 0 ]; then
+    _eval_replay_write_meta "$nonce" "$batch_grsha" "${model:-unknown}" "$n" "$prompt_sha_acc"
+  fi
 
   echo
   if [ "$total_evaluated" -eq 0 ]; then
@@ -4457,8 +4678,13 @@ function cmd_eval {
     echo "ABORTED: circuit breaker tripped on first fixture UNRELIABLE - $total_evaluated of $n_expected fixtures evaluated."
     return 2
   fi
-  _eval_print_scorecard "$nonce"
+  if [ "$replay_mode" -eq 0 ]; then
+    _eval_print_scorecard "$nonce"
+  fi
   echo
+  if [ "$replay_mode" -eq 1 ]; then
+    echo "replay: $total_evaluated fixture(s) (keyless)"
+  fi
   if [ "$total_mismatch" -eq 0 ] && [ "$total_unreliable" -eq 0 ]; then
     echo "PASS: all $total_evaluated evaluated fixture(s) majority-matched their expected verdict."
     return 0
@@ -4506,9 +4732,14 @@ usage: bash flow.sh <command> [args]
   promote <file>    Copy a playbook into the cross-project KB (~/.claude/flow/playbooks)
   doctor            Check the environment (bash/python/grep/git) across macOS/Linux/Windows
   eval [opts]       Behavioral eval: does the LLM semantic gate flag a hollow-but-mechanically-clean
-                     fixture? Opt-in, BILLABLE (skips cleanly with zero calls if 'claude' CLI absent).
+                     fixture? Opt-in, BILLABLE (live mode skips cleanly with zero calls if 'claude'
+                     CLI absent; --replay never inherits that SKIP).
                      [--stage 01|02|05|card|routing|converge] [--fixture <id>] [--n 3] [--timeout <seconds>]
                      [--report]  offline: last complete batch's scorecard + drift, zero calls
+                     [--record]  live: write stripped transcripts under eval/replay/ (billable)
+                     [--replay]  keyless: feed recorded transcripts through parse/vote/scorecard
+                     --record|--replay are artifact-modality only (not --stage routing|converge,
+                     not --report). --replay is not a fresh-judge and never counts toward the floor.
                      --stage routing: SEPARATE judge (concierge routing, not gate-rules FLAG/PASS);
                      hard-capped at 90 calls/batch, own results stream, own --report
   retro             Print the 3 retro questions

package/skills-manifest.json

@@ -1,8 +1,8 @@
 {
   "source": "../skills/flow",
   "destRelative": "skills/flow",
-  "fileCount": 100,
-  "syncedAt": "2026-08-13T12:49:42.684Z",
+  "fileCount": 103,
+  "syncedAt": "2026-08-20T13:35:30.768Z",
   "fileList": [
     "SKILL.md",
     "_templates/00-idea.md",
@@ -35,6 +35,8 @@
     "eval/fixtures/fcdb/cards/C-001.md",
     "eval/fixtures/fcdc/.flow/.gitkeep",
     "eval/fixtures/fcdc/cards/C-001.md",
+    "eval/fixtures/fcdd/cards/C-001.md",
+    "eval/fixtures/fcde/cards/C-001.md",
     "eval/fixtures/routing/manifest.tsv",
     "eval/fixtures/routing/states/state-any-midproject.txt",
     "eval/fixtures/routing/states/state-cards-todo.txt",
@@ -95,6 +97,7 @@
     "references/gate-eval.md",
     "references/gate-rules.md",
     "references/ground-truth-gates.md",
+    "references/host-agnostic-parallel.md",
     "references/loop-harness-2026-principles.md",
     "references/mode-work.md",
     "references/native-rituals.md",