@manhquy/flow-skill 0.7.0 → 0.7.2

package/skills/flow/runner/flow.sh

@@ -171,6 +171,7 @@ current_stage_idx() { # highest CONTIGUOUS-from-00 stage index, or -1 if 00 miss
 # Prints violations; returns 0 = clean, 1 = violations found.
 scan_gate() {
   local file="$1" found=0 unchecked fills
+  _MIDTIER_FAILS=0
   if [ ! -f "$file" ]; then
     echo "  missing file: $file"
     return 1
@@ -187,9 +188,132 @@ scan_gate() {
     printf '%s\n' "$fills" | sed 's/^/      L/'
     found=1
   fi
+  case "$(basename "$file")" in
+    01-research.md|02-scope.md|03-prd.md|05-contract.md)
+      if ! _scan_midtier "$file"; then
+        found=1
+      fi
+      ;;
+  esac
   return $found
 }
 
+# Materialize a ## heading body into stdout (one awk; caller assigns to a var).
+# Copy of cmd_clarify's heading walk: start at heading, stop at the next ##.
+_heading_slice() { # $1=file $2=heading prefix after "## "
+  local file="$1" heading="$2"
+  awk -v h="$heading" '
+    {
+      line = $0
+      sub(/\r$/, "", line)
+    }
+    line ~ ("^##[[:space:]]+" h) { f=1; next }
+    /^##[[:space:]]/ { f=0 }
+    f { print line }
+  ' "$file"
+}
+
+_midtier_hit() {
+  echo "  [x] $1"
+  _MIDTIER_FAILS=$((_MIDTIER_FAILS + 1))
+}
+
+_midtier_entry_n() { # stdin = ## What exists already -> numbered or bullet entries
+  awk '
+    /^[[:space:]]*[0-9]+\./ { c++; next }
+    /^[[:space:]]*- / { c++ }
+    END { print c + 0 }
+  '
+}
+
+_midtier_l_above_a() { # stdin = ## Features in v1 body; exit 1 if a joined bullet is L + B/C
+  awk '
+    function flush() {
+      if (buf == "") return
+      low = tolower(buf)
+      hasL = (low ~ /impact[[:space:]]*:?[[:space:]]*l([^a-z]|$)/ || low ~ /(^|[^a-z])l-impact/)
+      hasBC = (low ~ /grade[[:space:]]*:?[[:space:]]*[bc]([^a-z]|$)/)
+      if (hasL && hasBC) bad++
+      buf = ""
+    }
+    /^[[:space:]]*- / { flush(); buf = $0; next }
+    /^[[:space:]]*$/ { flush(); next }
+    buf != "" { buf = buf " " $0; next }
+    { flush() }
+    END { flush(); exit (bad > 0) ? 1 : 0 }
+  '
+}
+
+_midtier_adjectives() { # stdin = Features or NFR body; print first listed adjective
+  awk '
+    /^[[:space:]]*- \[[ xX]\]/ { next }
+    {
+      line = tolower($0)
+      n = split("fast secure intuitive robust prominent", w, " ")
+      for (i = 1; i <= n; i++) {
+        if (line ~ "(^|[^a-z])" w[i] "([^a-z]|$)") { print w[i]; exit }
+      }
+    }
+  '
+}
+
+_midtier_od_n() { # stdin = ## Open decisions body -> markdown bullet count (checked or not)
+  awk '/^[[:space:]]*- / { c++ } END { print c + 0 }'
+}
+
+_midtier_open_decisions() { # $1=file
+  local body n
+  body="$(_heading_slice "$1" "Open decisions")"
+  n="$(printf '%s\n' "$body" | _midtier_od_n)"
+  if [ "$n" -gt 5 ]; then
+    _midtier_hit "more than 5 ## Open decisions bullets ($n)"
+  fi
+}
+
+_scan_midtier() { # $1=file; prints [x] lines; return 1 if any hit
+  local file="$1" base body n pt adj
+  base="$(basename "$file")"
+  case "$base" in
+    01-research.md)
+      if [ -f "$PROJECT_TYPE_FILE" ]; then
+        pt="$(tr -d '\r' < "$PROJECT_TYPE_FILE" | awk 'NF{print; exit}')"
+        if [ "$pt" = "web" ]; then
+          body="$(_heading_slice "$file" "What exists already")"
+          n="$(printf '%s\n' "$body" | _midtier_entry_n)"
+          if [ "$n" -lt 3 ]; then
+            _midtier_hit "fewer than 3 entries under ## What exists already (typed web, got $n)"
+          fi
+        fi
+      fi
+      ;;
+    02-scope.md)
+      body="$(_heading_slice "$file" "Features in v1")"
+      if ! printf '%s\n' "$body" | _midtier_l_above_a; then
+        _midtier_hit "L-impact feature above grade A in ## Features in v1"
+      fi
+      _midtier_open_decisions "$file"
+      ;;
+    03-prd.md)
+      body="$(_heading_slice "$file" "Features")"
+      adj="$(printf '%s\n' "$body" | _midtier_adjectives)"
+      if [ -n "$adj" ]; then
+        _midtier_hit "unquantified adjective '$adj' in ## Features"
+      else
+        body="$(_heading_slice "$file" "Non-functional requirements")"
+        adj="$(printf '%s\n' "$body" | _midtier_adjectives)"
+        if [ -n "$adj" ]; then
+          _midtier_hit "unquantified adjective '$adj' in ## Non-functional requirements"
+        fi
+      fi
+      _midtier_open_decisions "$file"
+      ;;
+    05-contract.md)
+      _midtier_open_decisions "$file"
+      ;;
+  esac
+  [ "$_MIDTIER_FAILS" -eq 0 ]
+}
+
 _python() {
   # prefer python3, and only accept an interpreter that is actually Python 3.x (the harness +
   # repo_map.py are py3-only — a py2 `python` must NOT be selected or it fails silently).
@@ -437,6 +561,18 @@ planning_complete() { # 0 = yes: each stage is clean, OR debt-skipped (a skipped
   return 0
 }
 
+# Files exist (or debt-skipped). Used by project-type lock so a midtier-dirty
+# 01 cannot unlock a type flip after stages 00-05 are on disk.
+planning_artifacts_present() {
+  local s
+  for s in $STAGES; do
+    if [ ! -f "$FLOW_DIR/$s.md" ]; then
+      stage_skipped "$s" || return 1
+    fi
+  done
+  return 0
+}
+
 # project type (web|cli|library|skill); absent => web. Adapts done-evidence + guidance.
 get_project_type() {
   local t; t="$(cat "$PROJECT_TYPE_FILE" 2>/dev/null | tr -d '\r' | awk 'NF{print; exit}')"
@@ -759,7 +895,7 @@ cmd_status() {
   echo "  auto:    $_ast$([ "$_ast" = ACTIVE ] && echo " (receipts enforced)" || true)"
   lock_warn
   echo
-  echo "NEXT -> $(_next_action)"
+  _emit_next
   echo
   if [ -f "$FLOW_DIR/00-inspect.md" ]; then
     if scan_gate "$FLOW_DIR/00-inspect.md" >/dev/null 2>&1; then
@@ -856,7 +992,9 @@ _resume_valid_lines() {
 cmd_resume() {
   local idx; idx="$(current_stage_idx)"
   if [ "$idx" -lt 0 ]; then
-    echo "nothing to resume - $(_next_action)"
+    _na="$(_next_action)"
+    echo "nothing to resume - $_na"
+    echo "NEXT_VERB=$(_next_verb_from "$_na")"
     return 0
   fi
 
@@ -874,7 +1012,7 @@ cmd_resume() {
     echo
     _gate_state_brief "$idx"
     echo
-    echo "NEXT -> $(_next_action)"
+    _emit_next
     return 0
   fi
 
@@ -966,7 +1104,7 @@ cmd_resume() {
   echo
 
   # ---- NEXT (shared with `status` via _next_action - the two verbs can never disagree) ----
-  echo "NEXT -> $(_next_action)"
+  _emit_next
 }
 
 cmd_next() {
@@ -1005,7 +1143,7 @@ cmd_next() {
     # attribute the failing event to THIS stage (so usage top-fail-stage + propose can see it)
     # and record WHICH checks failed, so a chronically-failing stage is diagnosable.
     FLOW_LOG_STAGE_TO="$cur"
-    FLOW_LAST_GATE_FAIL="fill:$(grep -c '\[FILL' "$FLOW_DIR/$cur.md" 2>/dev/null || echo 0),unchecked:$(grep -cE '^[[:space:]]*- \[ \]' "$FLOW_DIR/$cur.md" 2>/dev/null || echo 0)"
+    FLOW_LAST_GATE_FAIL="fill:$(grep -c '\[FILL' "$FLOW_DIR/$cur.md" 2>/dev/null || echo 0),unchecked:$(grep -cE '^[[:space:]]*- \[ \]' "$FLOW_DIR/$cur.md" 2>/dev/null || echo 0),midtier:${_MIDTIER_FAILS:-0}"
     echo
     echo "Fix the above, then run '/flow next' again. (Kill at a gate is also valid.)"
     return 1
@@ -1179,6 +1317,27 @@ _next_action() {
   echo "run '/flow check' then ship per stage 09"
 }
 
+# Closed advisory enum from _next_action prose only. Hosts must not auto-exec auto/skip.
+_next_verb_from() { # $1 = _next_action text
+  local a="$1"
+  case "$a" in
+    *"fix gate:"*) echo fix-gate ;;
+    *"/flow card start"*) echo card-start ;;
+    *"/flow card"*) echo card ;;
+    *"/flow check"*) echo check ;;
+    *"/flow next"*) echo next ;;
+    *"in flight"*) echo card-start ;;
+    *) echo none ;;
+  esac
+}
+
+_emit_next() {
+  local a
+  a="$(_next_action)"
+  echo "NEXT -> $a"
+  echo "NEXT_VERB=$(_next_verb_from "$a")"
+}
+
 _set_card_status() { # $1=file $2=value -> rewrite the ^status: line (portable substitute; temp+mv)
   local f="$1" v="$2"
   sed "s/^status:.*/status: $v/" "$f" > "$f.tmp" 2>/dev/null || { rm -f "$f.tmp"; return 1; }
@@ -1590,12 +1749,13 @@ cmd_project_type() {
   fi
   case "$arg" in
     web|cli|library|skill)
-      # After planning is complete AND an explicit type file exists, refuse silent
+      # After planning artifacts exist AND an explicit type file exists, refuse silent
       # type flips unless FLOW_FORCE=1 (D6). Default-web with no file is not "locked".
-      if planning_complete 2>/dev/null && [ -f "$PROJECT_TYPE_FILE" ]; then
+      # Gate cleanliness is NOT required: a midtier-dirty 01 must not unlock a flip.
+      if planning_artifacts_present 2>/dev/null && [ -f "$PROJECT_TYPE_FILE" ]; then
         local cur; cur="$(get_project_type)"
         if [ -n "$cur" ] && [ "$cur" != "$arg" ] && [ "${FLOW_FORCE:-0}" != "1" ]; then
-          echo "FAIL: project type is locked to '$cur' after planning completes (would change done-evidence lens)."
+          echo "FAIL: project type is locked to '$cur' once planning artifacts exist (would change done-evidence lens)."
           echo "  re-set with FLOW_FORCE=1 if intentional, and record a DEBT.md line for the change."
           return 1
         fi
@@ -2302,6 +2462,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).')"
@@ -3154,17 +3322,26 @@ _eval_heading_pattern() {
   esac
 }
 
-# Extract one stage's ritual text: from its heading line up to (not including) the next '## '
-# heading, or EOF. Prints nothing on a bad stage/missing file - caller MUST assert non-empty
-# before any billable call (a silent empty extraction would judge against no rule at all).
+# Extract one stage's ritual text from the mapped file (01→gate-01.md, 02→gate-02.md,
+# card→gate-card.md): from its heading line up to (not including) the next '## '
+# heading, or EOF. Prints nothing on a bad stage/missing file - caller MUST assert
+# non-empty before any billable call (a silent empty extraction would judge against
+# no rule at all).
 _eval_extract_section() { # $1 = stage (01|02|card)
-  local pat; pat="$(_eval_heading_pattern "$1")" || return 1
-  [ -f "$GATE_RULES_FILE" ] || return 1
+  local pat src
+  pat="$(_eval_heading_pattern "$1")" || return 1
+  case "$1" in
+    01)   src="$SCRIPT_DIR/../references/gate-01.md" ;;
+    02)   src="$SCRIPT_DIR/../references/gate-02.md" ;;
+    card) src="$SCRIPT_DIR/../references/gate-card.md" ;;
+    *)    return 1 ;;
+  esac
+  [ -f "$src" ] || return 1
   awk -v pat="$pat" '
     $0 ~ pat { f=1; print; next }
     f && /^## / { f=0 }
     f { print }
-  ' "$GATE_RULES_FILE"
+  ' "$src"
 }
 
 # Usability probe: zero cost if `claude` is absent; exactly one minimal billable call if present.
@@ -3199,13 +3376,39 @@ _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.
+# Build the judge prompt for one fixture. The challenge block is the extract output
+# (already the judge bytes; `_eval_gate_rules_sha` is not stdin). Returns 1 if empty.
 _eval_build_prompt() { # $1=outfile $2=stage $3=artifact-file $4=nonce
-  local outfile="$1" stage="$2" artifact="$3" nonce="$4" section
+  local outfile="$1" stage="$2" artifact="$3" nonce="$4" section shared
   section="$(_eval_extract_section "$stage")" || return 1
   [ -n "$section" ] || return 1
+  # Shared OD/authority lives in 02/03/05 challenges. Extract maps 01/02/card only;
+  # appending shared onto 01/card lets OD rules false-FLAG research/evidence.
+  if [ "$stage" = "02" ]; then
+    shared="$SCRIPT_DIR/../references/gate-shared.md"
+    [ -f "$shared" ] && section="$section
+$(cat "$shared")"
+  fi
   {
     printf 'You are reviewing a build-process artifact against the quality-gate challenge below.\n'
     printf 'Read the challenge, then the artifact, then decide honestly: does the artifact\n'
@@ -3284,11 +3487,34 @@ _eval_nonce_epoch() { # $1=run_id -> epoch seconds (or empty)
   printf '%s' "$1" | awk -F- 'NF>=2 { print $(NF-1) }'
 }
 
-# CRLF-normalized gate-rules.md hash: a raw-byte hash would differ per checkout line-endings
-# (git autocrlf) and produce a false "prose changed" drift alarm across identical content.
+# CRLF-normalized hash of the explicit gate-rules corpus (index + shared + 11
+# section files). Never glob `gate-*.md` (would pull gate-eval.md + gate-examples.md).
+# A raw-byte hash would differ per checkout line-endings (git autocrlf).
 _eval_gate_rules_sha() {
-  [ -f "$GATE_RULES_FILE" ] || { printf 'unknown'; return; }
-  tr -d '\r' < "$GATE_RULES_FILE" | cksum | awk '{print $1}'
+  local ref="$SCRIPT_DIR/../references"
+  [ -f "$ref/gate-rules.md" ] || { printf 'unknown'; return; }
+  {
+    cat "$ref/gate-rules.md"
+    [ -f "$ref/gate-shared.md" ] && cat "$ref/gate-shared.md"
+    [ -f "$ref/gate-assess.md" ] && cat "$ref/gate-assess.md"
+    [ -f "$ref/gate-00.md" ] && cat "$ref/gate-00.md"
+    [ -f "$ref/gate-01.md" ] && cat "$ref/gate-01.md"
+    [ -f "$ref/gate-02.md" ] && cat "$ref/gate-02.md"
+    [ -f "$ref/gate-03.md" ] && cat "$ref/gate-03.md"
+    [ -f "$ref/gate-04.md" ] && cat "$ref/gate-04.md"
+    [ -f "$ref/gate-05.md" ] && cat "$ref/gate-05.md"
+    [ -f "$ref/gate-card.md" ] && cat "$ref/gate-card.md"
+    [ -f "$ref/gate-consistency.md" ] && cat "$ref/gate-consistency.md"
+    [ -f "$ref/gate-constitution.md" ] && cat "$ref/gate-constitution.md"
+    [ -f "$ref/gate-debt.md" ] && cat "$ref/gate-debt.md"
+  } | tr -d '\r' | 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
@@ -3317,9 +3543,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 +3593,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 +3888,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() {
@@ -3744,6 +3973,9 @@ _eval_routing_print_scorecard() { # $1=run_id
   '
 }
 
+_eval_skip_unmeasured() { # $1 = kind (eval / routing eval / converge eval)
+  echo "SKIP: 'claude' CLI not found on PATH - $1 needs it to run the LLM judge. Zero calls made."
+}
 # 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
@@ -3770,10 +4002,13 @@ 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."
+      _eval_skip_unmeasured "routing eval"
+      echo "semantic layer unmeasured on this host"
       return 0 ;;
     fail)
       echo "SKIP: 'claude' CLI is present but the sentinel probe did not come back clean (one minimal"
@@ -3838,14 +4073,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 +4096,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 +4136,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 +4244,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,9 +4315,11 @@ 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 ;;
+    absent) _eval_skip_unmeasured "converge eval"; echo "semantic layer unmeasured on this host"; 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 ;;
   esac
 
@@ -4123,17 +4365,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 +4403,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
@@ -4189,6 +4434,8 @@ _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
+  # No judge binary => no stuck call to bound. Probe SKIP (unmeasured) owns this case.
+  command -v claude >/dev/null 2>&1 || return 0
   local darwin=0
   if [ "${FLOW_EVAL_FORCE_DARWIN:-}" = "1" ]; then
     darwin=1
@@ -4297,7 +4544,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,12 +4567,17 @@ 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."
+        _eval_skip_unmeasured "eval"
+        echo "semantic layer unmeasured on this host"
         return 0 ;;
       fail)
         echo "SKIP: 'claude' CLI is present but the sentinel probe did not come back clean (one minimal"
@@ -4425,13 +4677,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 +4717,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 +4753,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 +4831,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 +4863,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