@ai-dev-methodologies/rlp-desk 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-dev-methodologies/rlp-desk",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Fresh-context iterative loops for Claude Code — autonomous task completion with independent verification",
   "scripts": {
     "postinstall": "node scripts/postinstall.js",

package/src/commands/rlp-desk.md

@@ -31,10 +31,16 @@ Ask about these items one by one (or in small groups):
 5. **Verification Commands** — build, test, lint commands
 6. **Completion / Blocked Criteria**
 7. **Worker / Verifier Model** — haiku, sonnet, opus. Suggest defaults (worker: sonnet, verifier: opus), ask if OK.
-8. **Engine** — claude (default) or codex for Worker/Verifier. Ask: "Use claude (default) or codex for Worker/Verifier?" If codex: ask for model (default: gpt-5.4) and reasoning effort (default: high).
+8. **Engine & Model** — For each role (Worker, Verifier):
+   - Engine: claude (default) or codex
+   - If claude: suggest model (haiku/sonnet/opus) based on task complexity
+   - If codex: suggest model (default: gpt-5.4) and reasoning effort (low/medium/high)
+   - AI should recommend: "For this task complexity, I suggest Worker: sonnet, Verifier: opus"
+   - If codex selected: "For codex Worker, I suggest gpt-5.4 with high reasoning"
 9. **Verify Mode** — per-us (default) or batch. Ask: "Verify after each user story (per-us, recommended) or only after all stories are done (batch)?" Default recommendation: per-us for 2+ stories.
 10. **Verify Consensus** — Ask: "Use cross-engine consensus verification? (Both claude and codex verify independently, both must pass.) Requires codex CLI." Default: no.
-11. **Max Iterations** — suggest based on story count, ask if OK.
+11. **Consensus Scope** — If consensus enabled, ask: "Consensus on every verify (all, default) or only on final verify (final-only)?" Default: all.
+12. **Max Iterations** — suggest based on story count, ask if OK.
 
 After all items are confirmed, present the full contract summary.
 On approval, offer to run `init`.
@@ -48,6 +54,25 @@ Do NOT auto-decide iteration unit — the user MUST explicitly choose.
 Run: `~/.claude/ralph-desk/init_ralph_desk.zsh <slug> "<objective>"`
 If brainstorm was done, auto-fill PRD and test-spec with the results.
 
+**After init completes, STOP. Do NOT auto-run the loop.**
+
+Tell the user:
+1. The scaffold has been created — list the generated files
+2. Ask them to review/edit the PRD and test-spec if needed
+3. Show the run command with available options:
+```
+/rlp-desk run <slug> [options]
+
+Options:
+  --mode agent|tmux
+  --worker-engine claude|codex
+  --verifier-engine claude|codex
+  --verify-mode per-us|batch
+  --verify-consensus
+  --consensus-scope all|final-only
+```
+4. Wait for the user to explicitly invoke `/rlp-desk run`
+
 ---
 
 ## `run <slug> [options]`
@@ -61,12 +86,17 @@ Options (parse from `$ARGUMENTS`):
 - `--verifier-model MODEL` (default: opus)
 - `--worker-engine claude|codex` (default: `claude`) — engine for Worker
 - `--verifier-engine claude|codex` (default: `claude`) — engine for Verifier
-- `--codex-model MODEL` (default: `gpt-5.4`) — model passed to codex CLI
-- `--codex-reasoning low|medium|high` (default: `high`) — reasoning effort for codex
+- `--worker-codex-model MODEL` (default: `gpt-5.4`) — codex model for Worker
+- `--worker-codex-reasoning low|medium|high` (default: `high`) — reasoning for Worker
+- `--verifier-codex-model MODEL` (default: `gpt-5.4`) — codex model for Verifier
+- `--verifier-codex-reasoning low|medium|high` (default: `high`) — reasoning for Verifier
 - `--verify-mode per-us|batch` (default: `per-us`) — verification strategy
   - `per-us`: verify after each US, then final full verify of all AC
   - `batch`: verify only after all US done (legacy behavior)
 - `--verify-consensus` — enable cross-engine consensus verification (both claude and codex verify independently; both must pass)
+- `--consensus-scope all|final-only` — when consensus runs (default: `all`)
+  - `all`: consensus runs on every verify (current behavior)
+  - `final-only`: consensus only on final ALL verify
 - `--debug` — enable debug logging (tmux mode only, writes to logs/<slug>/debug.log)
 
 ### Mode Selection
@@ -90,10 +120,13 @@ WORKER_MODEL=<--worker-model value> \
 VERIFIER_MODEL=<--verifier-model value> \
 WORKER_ENGINE=<--worker-engine value, default: claude> \
 VERIFIER_ENGINE=<--verifier-engine value, default: claude> \
-CODEX_MODEL=<--codex-model value, default: gpt-5.4> \
-CODEX_REASONING=<--codex-reasoning value, default: high> \
+WORKER_CODEX_MODEL=<--worker-codex-model value, default: gpt-5.4> \
+WORKER_CODEX_REASONING=<--worker-codex-reasoning value, default: high> \
+VERIFIER_CODEX_MODEL=<--verifier-codex-model value, default: gpt-5.4> \
+VERIFIER_CODEX_REASONING=<--verifier-codex-reasoning value, default: high> \
 VERIFY_MODE=<--verify-mode value, default: per-us> \
 VERIFY_CONSENSUS=<1 if --verify-consensus, else 0> \
+CONSENSUS_SCOPE=<--consensus-scope value, default: all> \
 DEBUG=<1 if --debug, else 0> \
   zsh ~/.claude/ralph-desk/run_ralph_desk.zsh
 ```
@@ -161,7 +194,7 @@ Agent(
 
 If `--worker-engine codex`:
 ```
-Bash("codex exec --model <codex_model> --reasoning-effort <codex_reasoning> <full worker prompt text>")
+Bash("codex exec --model <worker_codex_model> --reasoning-effort <worker_codex_reasoning> <full worker prompt text>")
 ```
 - Codex runs as a subprocess via Bash(), not Agent().
 - Each Bash() call = fresh context for codex.
@@ -206,7 +239,7 @@ Agent(
 
 If `--verifier-engine codex`:
 ```
-Bash("codex exec --model <codex_model> --reasoning-effort <codex_reasoning> <full verifier prompt text>")
+Bash("codex exec --model <verifier_codex_model> --reasoning-effort <verifier_codex_reasoning> <full verifier prompt text>")
 ```
 
 **⑦b Consensus Verification** (when `--verify-consensus` is enabled):
@@ -302,10 +335,13 @@ Run options:
   --verifier-model MODEL     Verifier model (default: opus)
   --worker-engine claude|codex   Worker engine (default: claude)
   --verifier-engine claude|codex Verifier engine (default: claude)
-  --codex-model MODEL        Codex model (default: gpt-5.4)
-  --codex-reasoning LEVEL    Codex reasoning (default: high)
+  --worker-codex-model MODEL          Worker codex model (default: gpt-5.4)
+  --worker-codex-reasoning LEVEL      Worker codex reasoning (default: high)
+  --verifier-codex-model MODEL        Verifier codex model (default: gpt-5.4)
+  --verifier-codex-reasoning LEVEL    Verifier codex reasoning (default: high)
   --verify-mode per-us|batch Verification strategy (default: per-us)
   --verify-consensus         Cross-engine consensus verification
+  --consensus-scope SCOPE    When consensus runs: all|final-only (default: all)
   --debug                    Debug logging (tmux mode only)
 ```
 

package/src/scripts/run_ralph_desk.zsh

@@ -29,6 +29,16 @@ set -uo pipefail
 #   IDLE_NUDGE_THRESHOLD      - seconds of idle before nudge (default: 30)
 #   MAX_NUDGES                - max nudges per pane per iteration (default: 3)
 #
+# Per-role codex config:
+#   WORKER_CODEX_MODEL            - codex model for Worker (default: gpt-5.4)
+#   WORKER_CODEX_REASONING        - codex reasoning for Worker (default: high)
+#   VERIFIER_CODEX_MODEL          - codex model for Verifier (default: gpt-5.4)
+#   VERIFIER_CODEX_REASONING      - codex reasoning for Verifier (default: high)
+#
+# Consensus scope:
+#   CONSENSUS_SCOPE               - when consensus applies (default: all)
+#                                   all=every verify, final-only=final ALL only
+#
 # Dependencies: tmux, claude CLI, jq
 # Optional: codex CLI (required when WORKER_ENGINE=codex, VERIFIER_ENGINE=codex, or VERIFY_CONSENSUS=1)
 # =============================================================================
@@ -49,13 +59,16 @@ MAX_NUDGES="${MAX_NUDGES:-3}"
 # --- Engine Selection ---
 WORKER_ENGINE="${WORKER_ENGINE:-claude}"    # claude|codex
 VERIFIER_ENGINE="${VERIFIER_ENGINE:-claude}"  # claude|codex
-CODEX_MODEL="${CODEX_MODEL:-gpt-5.4}"
-CODEX_REASONING="${CODEX_REASONING:-high}"   # low|medium|high
+WORKER_CODEX_MODEL="${WORKER_CODEX_MODEL:-gpt-5.4}"
+WORKER_CODEX_REASONING="${WORKER_CODEX_REASONING:-high}"   # low|medium|high
+VERIFIER_CODEX_MODEL="${VERIFIER_CODEX_MODEL:-gpt-5.4}"
+VERIFIER_CODEX_REASONING="${VERIFIER_CODEX_REASONING:-high}"   # low|medium|high
 CODEX_BIN=""  # resolved by check_dependencies when engine=codex
 
 # --- Verify Mode ---
 VERIFY_MODE="${VERIFY_MODE:-per-us}"        # per-us|batch
 VERIFY_CONSENSUS="${VERIFY_CONSENSUS:-0}"   # 0|1
+CONSENSUS_SCOPE="${CONSENSUS_SCOPE:-all}"   # all|final-only
 
 # --- Derived Paths ---
 DESK="$ROOT/.claude/ralph-desk"
@@ -127,6 +140,31 @@ atomic_write() {
   mv "$tmp" "$target"
 }
 
+# --- omc-teams pattern: Kill-and-replace dead/stuck worker panes ---
+replace_worker_pane() {
+  local old_pane="$1"
+  local role="$2"  # "worker" or "verifier"
+
+  log "  Replacing dead $role pane $old_pane..."
+  tmux kill-pane -t "$old_pane" 2>/dev/null
+
+  # Create fresh pane via split-window off leader (omc-teams kill-and-replace pattern)
+  local new_pane
+  new_pane=$(tmux split-window -h -d -t "$LEADER_PANE" -P -F '#{pane_id}' -c "$ROOT")
+
+  log "  New $role pane: $new_pane (replaced $old_pane)"
+  log_debug "[EXEC] iter=$ITERATION pane_replaced=${role} old=$old_pane new=$new_pane"
+
+  # Update session-config.json with new pane ID
+  if [[ -f "$SESSION_CONFIG" ]]; then
+    jq --arg role "$role" --arg pane "$new_pane" \
+      '.panes[$role] = $pane' "$SESSION_CONFIG" | atomic_write "$SESSION_CONFIG"
+    log_debug "Updated session-config.json: $role pane → $new_pane"
+  fi
+
+  echo "$new_pane"
+}
+
 # =============================================================================
 # Dependency Checks
 # =============================================================================
@@ -282,6 +320,19 @@ create_session() {
     "worker": "'"$WORKER_MODEL"'",
     "verifier": "'"$VERIFIER_MODEL"'"
   },
+  "engines": {
+    "worker": "'"$WORKER_ENGINE"'",
+    "verifier": "'"$VERIFIER_ENGINE"'",
+    "worker_codex_model": "'"$WORKER_CODEX_MODEL"'",
+    "worker_codex_reasoning": "'"$WORKER_CODEX_REASONING"'",
+    "verifier_codex_model": "'"$VERIFIER_CODEX_MODEL"'",
+    "verifier_codex_reasoning": "'"$VERIFIER_CODEX_REASONING"'"
+  },
+  "verification": {
+    "verify_mode": "'"$VERIFY_MODE"'",
+    "verify_consensus": '"$VERIFY_CONSENSUS"',
+    "consensus_scope": "'"$CONSENSUS_SCOPE"'"
+  },
   "config": {
     "max_iter": '"$MAX_ITER"',
     "poll_interval": '"$POLL_INTERVAL"',
@@ -590,7 +641,7 @@ restart_worker() {
 
   # Re-launch worker (tmux interactive pattern)
   if [[ "$WORKER_ENGINE" = "codex" ]]; then
-    safe_send_keys "$pane_id" "${CODEX_BIN:-codex} -m $CODEX_MODEL -c model_reasoning_effort=\"$CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
+    safe_send_keys "$pane_id" "${CODEX_BIN:-codex} -m $WORKER_CODEX_MODEL -c model_reasoning_effort=\"$WORKER_CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
   else
     safe_send_keys "$pane_id" "$CLAUDE_BIN --model $WORKER_MODEL --dangerously-skip-permissions"
   fi
@@ -681,8 +732,8 @@ write_worker_trigger() {
   # Write trigger script (DO NOT use exec -- breaks heartbeat cleanup)
   # Engine-specific launch command (expanded at write time)
   if [[ "$WORKER_ENGINE" = "codex" ]]; then
-    local engine_cmd="${CODEX_BIN:-codex} -m $CODEX_MODEL \\
-  -c model_reasoning_effort=\"$CODEX_REASONING\" \\
+    local engine_cmd="${CODEX_BIN:-codex} -m $WORKER_CODEX_MODEL \\
+  -c model_reasoning_effort=\"$WORKER_CODEX_REASONING\" \\
   --dangerously-bypass-approvals-and-sandbox \\
   \"\$(cat $prompt_file)\" \\
   2>&1 | tee $output_log"
@@ -768,8 +819,8 @@ write_verifier_trigger() {
   # Write trigger script (DO NOT use exec -- breaks heartbeat cleanup)
   # Engine-specific launch command (expanded at write time)
   if [[ "$verifier_engine" = "codex" ]]; then
-    local engine_cmd="${CODEX_BIN:-codex} -m $CODEX_MODEL \\
-  -c model_reasoning_effort=\"$CODEX_REASONING\" \\
+    local engine_cmd="${CODEX_BIN:-codex} -m $VERIFIER_CODEX_MODEL \\
+  -c model_reasoning_effort=\"$VERIFIER_CODEX_REASONING\" \\
   --dangerously-bypass-approvals-and-sandbox \\
   \"\$(cat $prompt_file)\" \\
   2>&1 | tee $output_log"
@@ -836,6 +887,7 @@ update_status() {
   local consensus_json=""
   if [[ "$VERIFY_CONSENSUS" = "1" ]]; then
     consensus_json=',
+  "consensus_scope": "'"$CONSENSUS_SCOPE"'",
   "consensus_round": '"$CONSENSUS_ROUND"',
   "claude_verdict": "'"${CLAUDE_VERDICT:-}"'",
   "codex_verdict": "'"${CODEX_VERDICT:-}"'"'
@@ -850,6 +902,10 @@ update_status() {
   "verifier_model": "'"$VERIFIER_MODEL"'",
   "worker_engine": "'"$WORKER_ENGINE"'",
   "verifier_engine": "'"$VERIFIER_ENGINE"'",
+  "worker_codex_model": "'"$WORKER_CODEX_MODEL"'",
+  "worker_codex_reasoning": "'"$WORKER_CODEX_REASONING"'",
+  "verifier_codex_model": "'"$VERIFIER_CODEX_MODEL"'",
+  "verifier_codex_reasoning": "'"$VERIFIER_CODEX_REASONING"'",
   "verify_mode": "'"$VERIFY_MODE"'",
   "verify_consensus": '"$VERIFY_CONSENSUS"',
   "last_result": "'"$last_result"'",
@@ -1212,7 +1268,7 @@ run_single_verifier() {
   # Launch verifier
   if [[ "$engine" = "codex" ]]; then
     # Codex: use non-interactive exec mode in pane (more reliable than TUI for sequential runs)
-    local codex_cmd="${CODEX_BIN:-codex} exec \"\$(cat $prompt_file)\" -m $CODEX_MODEL -c model_reasoning_effort=\"$CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
+    local codex_cmd="${CODEX_BIN:-codex} exec \"\$(cat $prompt_file)\" -m $VERIFIER_CODEX_MODEL -c model_reasoning_effort=\"$VERIFIER_CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
     log "  Running $suffix verifier (codex exec) in pane $VERIFIER_PANE..."
     tmux send-keys -t "$VERIFIER_PANE" -l -- "$codex_cmd"
     tmux send-keys -t "$VERIFIER_PANE" Enter
@@ -1237,7 +1293,7 @@ run_single_verifier() {
 
     # Verify claude actually started working
     local v_submit=0
-    while (( v_submit < 10 )); do
+    while (( v_submit < 15 )); do
       sleep 2
       local v_check
       v_check=$(tmux capture-pane -t "$VERIFIER_PANE" -p 2>/dev/null)
@@ -1245,6 +1301,14 @@ run_single_verifier() {
         log_debug "Verifier$suffix started working after $((v_submit + 1)) checks"
         break
       fi
+      # After 8 failed attempts, try C-u clear + re-type (omc-teams adaptive retry)
+      if (( v_submit == 8 )); then
+        log_debug "Adaptive instruction retry: clearing line and re-typing"
+        tmux send-keys -t "$VERIFIER_PANE" C-u 2>/dev/null
+        sleep 0.1
+        tmux send-keys -t "$VERIFIER_PANE" -l -- "$verifier_instruction"
+        tmux send-keys -t "$VERIFIER_PANE" Enter
+      fi
       tmux send-keys -t "$VERIFIER_PANE" C-m 2>/dev/null
       sleep 0.3
       tmux send-keys -t "$VERIFIER_PANE" C-m 2>/dev/null
@@ -1308,13 +1372,15 @@ run_consensus_verification() {
       return 1
     fi
     CLAUDE_VERDICT=$(jq -r '.verdict' "$claude_verdict_file" 2>/dev/null)
+    log_debug "[EXEC] iter=$iter phase=consensus_claude verdict=$CLAUDE_VERDICT model=$VERIFIER_MODEL"
 
     # Run codex verifier second
-    if ! run_single_verifier "$iter" "codex" "$CODEX_MODEL" "-codex" "$codex_verdict_file"; then
+    if ! run_single_verifier "$iter" "codex" "$VERIFIER_CODEX_MODEL" "-codex" "$codex_verdict_file"; then
       log_error "Codex verifier failed in consensus round $CONSENSUS_ROUND"
       return 1
     fi
     CODEX_VERDICT=$(jq -r '.verdict' "$codex_verdict_file" 2>/dev/null)
+    log_debug "[EXEC] iter=$iter phase=consensus_codex verdict=$CODEX_VERDICT model=$VERIFIER_CODEX_MODEL reasoning=$VERIFIER_CODEX_REASONING"
 
     log "  Consensus: claude=$CLAUDE_VERDICT codex=$CODEX_VERDICT"
     local _combined_action="retry"
@@ -1325,11 +1391,26 @@ run_consensus_verification() {
 
     # Both pass → success
     if [[ "$CLAUDE_VERDICT" = "pass" && "$CODEX_VERDICT" = "pass" ]]; then
-      # Merge verdicts: use claude verdict as primary, note codex agreement
-      cp "$claude_verdict_file" "$VERDICT_FILE"
+      # Create merged verdict with per-engine details
+      {
+        echo '{'
+        echo '  "verdict": "pass",'
+        echo '  "verified_at_utc": "'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'",'
+        echo '  "summary": "Consensus PASS: both claude and codex verified independently",'
+        echo '  "recommended_state_transition": "complete",'
+        echo '  "consensus": {'
+        echo '    "claude": { "verdict": "pass", "file": "'"$claude_verdict_file"'" },'
+        echo '    "codex": { "verdict": "pass", "file": "'"$codex_verdict_file"'" },'
+        echo '    "round": '"$CONSENSUS_ROUND"
+        echo '  }'
+        echo '}'
+      } | atomic_write "$VERDICT_FILE"
       return 0
     fi
 
+    # Consensus disagreement
+    log_debug "[EXEC] iter=$iter phase=consensus_disagreement round=$CONSENSUS_ROUND claude=$CLAUDE_VERDICT codex=$CODEX_VERDICT action=fix_contract"
+
     # Either fails → build combined fix contract
     local fix_contract="$LOGS_DIR/iter-$(printf '%03d' $iter).fix-contract.md"
     {
@@ -1431,6 +1512,7 @@ main() {
   log "  Verifier model:  $VERIFIER_MODEL"
   log "  Verify mode:     $VERIFY_MODE"
   log "  Verify consensus:$VERIFY_CONSENSUS"
+  log "  Consensus scope: $CONSENSUS_SCOPE"
   log "  Poll interval:   ${POLL_INTERVAL}s"
   log "  Iter timeout:    ${ITER_TIMEOUT}s"
   # --- Debug: Log execution plan ---
@@ -1446,7 +1528,7 @@ main() {
     log_debug "[PLAN] slug=$SLUG us_count=$us_count us_list=$us_list"
     log_debug "[PLAN] worker_engine=$WORKER_ENGINE worker_model=$WORKER_MODEL"
     log_debug "[PLAN] verifier_engine=$VERIFIER_ENGINE verifier_model=$VERIFIER_MODEL"
-    log_debug "[PLAN] verify_mode=$VERIFY_MODE consensus=$VERIFY_CONSENSUS max_iter=$MAX_ITER"
+    log_debug "[PLAN] verify_mode=$VERIFY_MODE consensus=$VERIFY_CONSENSUS consensus_scope=$CONSENSUS_SCOPE max_iter=$MAX_ITER"
 
     if [[ "$VERIFY_MODE" = "per-us" ]]; then
       # Build expected flow
@@ -1544,7 +1626,7 @@ main() {
     # Step 5a: Launch interactive worker engine in Worker pane
     local worker_launch
     if [[ "$WORKER_ENGINE" = "codex" ]]; then
-      worker_launch="${CODEX_BIN:-codex} -m $CODEX_MODEL -c model_reasoning_effort=\"$CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
+      worker_launch="${CODEX_BIN:-codex} -m $WORKER_CODEX_MODEL -c model_reasoning_effort=\"$WORKER_CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
       log "  Launching Worker codex in pane $WORKER_PANE..."
     else
       worker_launch="$CLAUDE_BIN --model $WORKER_MODEL --dangerously-skip-permissions"
@@ -1571,7 +1653,7 @@ main() {
 
     # Verify claude actually started working — keep sending C-m until activity detected
     local submit_attempts=0
-    while (( submit_attempts < 10 )); do
+    while (( submit_attempts < 15 )); do
       sleep 2
       local pane_check
       pane_check=$(tmux capture-pane -t "$WORKER_PANE" -p 2>/dev/null)
@@ -1580,14 +1662,22 @@ main() {
         log_debug "[EXEC] iter=$ITERATION worker_submit_check=OK attempts=$((submit_attempts + 1))"
         break
       fi
+      # After 8 failed attempts, try C-u clear + re-type (omc-teams adaptive retry)
+      if (( submit_attempts == 8 )); then
+        log_debug "Adaptive instruction retry: clearing line and re-typing"
+        tmux send-keys -t "$WORKER_PANE" C-u 2>/dev/null
+        sleep 0.1
+        tmux send-keys -t "$WORKER_PANE" -l -- "$worker_instruction"
+        tmux send-keys -t "$WORKER_PANE" Enter
+      fi
       tmux send-keys -t "$WORKER_PANE" C-m 2>/dev/null
       sleep 0.3
       tmux send-keys -t "$WORKER_PANE" C-m 2>/dev/null
       (( submit_attempts++ ))
     done
-    if (( submit_attempts >= 10 )); then
-      log "  WARNING: Could not confirm Worker started working after 10 attempts"
-      log_debug "[EXEC] iter=$ITERATION worker_submit_check=FAILED attempts=10"
+    if (( submit_attempts >= 15 )); then
+      log "  WARNING: Could not confirm Worker started working after 15 attempts"
+      log_debug "[EXEC] iter=$ITERATION worker_submit_check=FAILED attempts=15"
     fi
 
     # --- governance.md s7 step 5+6: Poll for Worker completion ---
@@ -1621,10 +1711,8 @@ main() {
           update_status "worker" "poll_failed"
           worker_poll_done=1  # exit poll loop, continue to next iteration
           log_debug "[EXEC] iter=$ITERATION poll_worker_dead=true worker_cmd=$worker_cmd"
-          # Kill dead worker session so next iteration starts fresh
-          tmux send-keys -t "$WORKER_PANE" C-c 2>/dev/null
-          tmux send-keys -t "$WORKER_PANE" "/exit" Enter 2>/dev/null
-          sleep 1
+          # Worker is truly dead/stuck — kill and replace pane (omc-teams pattern)
+          WORKER_PANE=$(replace_worker_pane "$WORKER_PANE" "worker")
         fi
       fi
     done
@@ -1666,8 +1754,17 @@ main() {
 
         update_status "verifier" "running"
 
-        # --- Consensus vs single verification ---
+        # --- Consensus scope check ---
+        local use_consensus=0
         if [[ "$VERIFY_CONSENSUS" = "1" ]]; then
+          case "$CONSENSUS_SCOPE" in
+            all) use_consensus=1 ;;
+            final-only) [[ "$signal_us_id" == "ALL" ]] && use_consensus=1 ;;
+          esac
+        fi
+
+        # --- Consensus vs single verification ---
+        if (( use_consensus )); then
           # US-004: Run consensus verification (claude + codex sequentially)
           local consensus_rc=0
           run_consensus_verification "$ITERATION" || consensus_rc=$?
@@ -1700,7 +1797,7 @@ main() {
 
           local verifier_launch
           if [[ "$VERIFIER_ENGINE" = "codex" ]]; then
-            verifier_launch="${CODEX_BIN:-codex} -m $CODEX_MODEL -c model_reasoning_effort=\"$CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
+            verifier_launch="${CODEX_BIN:-codex} -m $VERIFIER_CODEX_MODEL -c model_reasoning_effort=\"$VERIFIER_CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
             log "  Launching Verifier codex in pane $VERIFIER_PANE..."
           else
             verifier_launch="$CLAUDE_BIN --model $VERIFIER_MODEL --dangerously-skip-permissions"
@@ -1726,7 +1823,7 @@ main() {
 
           # Verify verifier actually started working
           local vs_submit=0
-          while (( vs_submit < 10 )); do
+          while (( vs_submit < 15 )); do
             sleep 2
             local vs_check
             vs_check=$(tmux capture-pane -t "$VERIFIER_PANE" -p 2>/dev/null)
@@ -1734,6 +1831,14 @@ main() {
               log_debug "Verifier started working after $((vs_submit + 1)) checks"
               break
             fi
+            # After 8 failed attempts, try C-u clear + re-type (omc-teams adaptive retry)
+            if (( vs_submit == 8 )); then
+              log_debug "Adaptive instruction retry: clearing line and re-typing"
+              tmux send-keys -t "$VERIFIER_PANE" C-u 2>/dev/null
+              sleep 0.1
+              tmux send-keys -t "$VERIFIER_PANE" -l -- "$verifier_instruction"
+              tmux send-keys -t "$VERIFIER_PANE" Enter
+            fi
             tmux send-keys -t "$VERIFIER_PANE" C-m 2>/dev/null
             sleep 0.3
             tmux send-keys -t "$VERIFIER_PANE" C-m 2>/dev/null
@@ -1745,6 +1850,8 @@ main() {
           if ! poll_for_signal "$VERDICT_FILE" "$VERIFIER_HEARTBEAT" "$VERIFIER_PANE" "$verifier_launch" "Verifier"; then
             log_error "Verifier poll failed"
             update_status "verifier" "poll_failed"
+            # Verifier is dead/stuck — kill and replace pane (omc-teams pattern)
+            VERIFIER_PANE=$(replace_worker_pane "$VERIFIER_PANE" "verifier")
             continue
           fi
         fi