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

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manhquy/flow-skill",
-  "version": "0.7.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

@@ -8,7 +8,7 @@ keywords: [flow, buildflow, gate, build, ship, scope, prd, contract, card, deplo
 license: MIT
 metadata:
   author: flow-skill
-  version: "0.30.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)."
 ---
 
@@ -190,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/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/gate-eval.md

@@ -90,6 +90,54 @@ unbounded-billing risk. Install GNU coreutils (`gtimeout`) or export `FLOW_EVAL_
 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 |

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

@@ -2302,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).')"
@@ -3199,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.
@@ -3291,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
@@ -3317,9 +3351,10 @@ _eval_replay_meta_get() { # $1=key -> value (empty + return 1 if missing)
   return 1
 }
 
-_eval_replay_write_meta() { # $1=nonce $2=gate_rules_sha $3=model $4=n
+_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"
+  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).
@@ -3366,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
@@ -3660,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() {
@@ -3770,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."
@@ -3838,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")"
@@ -3857,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
@@ -3897,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
@@ -4005,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
@@ -4075,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 ;;
@@ -4123,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
@@ -4158,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
@@ -4297,7 +4346,7 @@ function cmd_eval {
 
   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=""
+  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.
@@ -4320,9 +4369,13 @@ function cmd_eval {
       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
-    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 - eval needs it to run the LLM judge. Zero calls made."
@@ -4425,13 +4478,36 @@ function cmd_eval {
       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
@@ -4442,11 +4518,12 @@ function cmd_eval {
         raw="$(_eval_replay_vote "$fid" "$i")" || { rm -rf "$rundir" 2>/dev/null; trap - INT TERM; return 1; }
         rc=0
       else
-        raw="$(_eval_engine_run "$promptfile" "$timeout" 2>"$err1")"; rc=$?
+        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")"
@@ -4477,10 +4554,10 @@ function cmd_eval {
           raw="$(_eval_replay_vote "$fid" "$i")" || { rm -rf "$rundir" 2>/dev/null; trap - INT TERM; return 1; }
           rc=0
         else
-          raw="$(_eval_engine_run "$promptfile" "$timeout" 2>"$err2")"; rc=$?
+          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
@@ -4555,7 +4632,7 @@ function cmd_eval {
     fi
 
     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"
+      _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))
 
@@ -4587,7 +4664,7 @@ function cmd_eval {
     _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"
+    _eval_replay_write_meta "$nonce" "$batch_grsha" "${model:-unknown}" "$n" "$prompt_sha_acc"
   fi
 
   echo

package/skills-manifest.json

@@ -1,8 +1,8 @@
 {
   "source": "../skills/flow",
   "destRelative": "skills/flow",
-  "fileCount": 102,
-  "syncedAt": "2026-08-14T09:19:34.115Z",
+  "fileCount": 103,
+  "syncedAt": "2026-08-20T13:35:30.768Z",
   "fileList": [
     "SKILL.md",
     "_templates/00-idea.md",
@@ -97,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",