@ai-dev-methodologies/rlp-desk 0.7.3 → 0.7.5

package/package.json

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

package/src/scripts/lib_ralph_desk.zsh

@@ -30,9 +30,9 @@ log_error() {
 }
 
 # build_claude_cmd() — centralized claude CLI command builder
-# Single source of truth for all claude invocation flags (--no-mcp, DISABLE_OMC, etc.)
+# Single source of truth for all claude invocation flags (--mcp-config, DISABLE_OMC, --effort, etc.)
 # Inspired by codex-plugin-cc companion pattern: CLI abstraction in one place.
-# Args: $1=mode (tui|print)  $2=model  $3=prompt_file (print mode only)  $4=output_log (print mode only)
+# Args: $1=mode (tui|print)  $2=model  $3=prompt_file (print mode only)  $4=output_log (print mode only)  $5=effort (optional: low|medium|high|max)
 # Output: complete command string on stdout
 # Globals read: CLAUDE_BIN
 build_claude_cmd() {
@@ -40,8 +40,12 @@ build_claude_cmd() {
   local model="$2"
   local prompt_file="${3:-}"
   local output_log="${4:-}"
+  local effort="${5:-}"
 
-  local base="DISABLE_OMC=1 $CLAUDE_BIN --model $model --mcp-config '{}' --dangerously-skip-permissions"
+  local base="DISABLE_OMC=1 $CLAUDE_BIN --model $model --mcp-config '{\"mcpServers\":{}}' --strict-mcp-config --dangerously-skip-permissions"
+  if [[ -n "$effort" ]]; then
+    base="$base --effort $effort"
+  fi
   case "$mode" in
     tui)
       echo "$base"
@@ -57,10 +61,12 @@ build_claude_cmd() {
 }
 
 # parse_model_flag() — parse unified --worker-model / --verifier-model value
-# Colon format (model:reasoning) → codex engine; plain name → claude engine.
-# Spark alias: bare "spark" is expanded to full model ID "gpt-5.3-codex-spark".
+# Colon format: claude models (haiku/sonnet/opus) with effort → claude engine + effort
+#               codex models (gpt-*/spark) with reasoning → codex engine + reasoning
+#               plain name → claude engine (no effort override)
 # Usage:  parse_model_flag <value> <role>
-# Output (stdout): "engine model [reasoning]"  e.g. "codex gpt-5.4 medium" | "claude sonnet"
+# Output (stdout): "engine model [reasoning_or_effort]"
+#   e.g. "codex gpt-5.4 medium" | "claude opus max" | "claude sonnet"
 # Returns: 0 on success, 1 on invalid format (error written to stderr)
 parse_model_flag() {
   local value="$1"
@@ -68,16 +74,24 @@ parse_model_flag() {
   local colon_count
   colon_count=$(printf '%s' "$value" | tr -cd ':' | wc -c | tr -d ' ')
   if (( colon_count > 1 )); then
-    echo "ERROR: Invalid --${role}-model format '${value}'. Use 'model:reasoning' (codex) or 'model-name' (claude)." >&2
+    echo "ERROR: Invalid --${role}-model format '${value}'. Use 'model:effort' (claude) or 'model:reasoning' (codex)." >&2
     return 1
   fi
   if (( colon_count == 1 )); then
     local model="${value%%:*}"
-    local reasoning="${value##*:}"
-    if [[ "$model" == "spark" ]]; then
-      model="gpt-5.3-codex-spark"
-    fi
-    echo "codex $model $reasoning"
+    local level="${value##*:}"
+    # Detect engine by model name
+    case "$model" in
+      haiku|sonnet|opus)
+        echo "claude $model $level"
+        ;;
+      spark)
+        echo "codex gpt-5.3-codex-spark $level"
+        ;;
+      *)
+        echo "codex $model $level"
+        ;;
+    esac
   else
     echo "claude $value"
   fi

package/src/scripts/run_ralph_desk.zsh

@@ -57,20 +57,34 @@ MAX_RESTARTS="${MAX_RESTARTS:-3}"
 IDLE_NUDGE_THRESHOLD="${IDLE_NUDGE_THRESHOLD:-30}"
 MAX_NUDGES="${MAX_NUDGES:-3}"
 WITH_SELF_VERIFICATION="${WITH_SELF_VERIFICATION:-0}"
+AUTONOMOUS_MODE="${AUTONOMOUS_MODE:-0}"    # 1=don't stop on ambiguity, PRD is authoritative
 
-# --- Engine Selection (auto-detect from model format: name=claude, name:reasoning=codex) ---
-# If model contains ":", it's codex format — auto-set engine and split model/reasoning
+# --- Engine Selection (auto-detect from model format) ---
+# claude models (haiku/sonnet/opus) with :effort → claude engine + effort
+# codex models (gpt-*/spark) with :reasoning → codex engine + reasoning
+# plain name → claude engine (no effort/reasoning)
 _auto_detect_engine() {
-  local model_var="$1" engine_var="$2" codex_model_var="$3" codex_reasoning_var="$4"
+  local model_var="$1" engine_var="$2" codex_model_var="$3" codex_reasoning_var="$4" effort_var="${5:-}"
   local model_val="${(P)model_var}"
   if [[ "$model_val" == *:* ]]; then
     local model_part="${model_val%%:*}"
-    local reasoning_part="${model_val##*:}"
-    [[ "$model_part" == "spark" ]] && model_part="gpt-5.3-codex-spark"
-    eval "$engine_var=codex"
-    eval "$model_var=$model_part"
-    [[ -n "$codex_model_var" ]] && eval "$codex_model_var=$model_part"
-    [[ -n "$codex_reasoning_var" ]] && eval "$codex_reasoning_var=$reasoning_part"
+    local level_part="${model_val##*:}"
+    case "$model_part" in
+      haiku|sonnet|opus)
+        # Claude model with effort — keep engine as claude, store effort
+        eval "$engine_var=claude"
+        eval "$model_var=$model_part"
+        [[ -n "$effort_var" ]] && eval "$effort_var=$level_part"
+        ;;
+      *)
+        # Codex model with reasoning
+        [[ "$model_part" == "spark" ]] && model_part="gpt-5.3-codex-spark"
+        eval "$engine_var=codex"
+        eval "$model_var=$model_part"
+        [[ -n "$codex_model_var" ]] && eval "$codex_model_var=$model_part"
+        [[ -n "$codex_reasoning_var" ]] && eval "$codex_reasoning_var=$level_part"
+        ;;
+    esac
   fi
 }
 
@@ -78,10 +92,15 @@ WORKER_ENGINE="${WORKER_ENGINE:-claude}"
 VERIFIER_ENGINE="${VERIFIER_ENGINE:-claude}"
 FINAL_VERIFIER_ENGINE="${FINAL_VERIFIER_ENGINE:-claude}"
 
+# Effort levels for Claude models (set by _auto_detect_engine or CLI --worker-model opus:max)
+WORKER_EFFORT="${WORKER_EFFORT:-}"
+VERIFIER_EFFORT="${VERIFIER_EFFORT:-}"
+FINAL_VERIFIER_EFFORT="${FINAL_VERIFIER_EFFORT:-}"
+
 # Auto-detect engine from model format for env var path (CLI path uses parse_model_flag)
-_auto_detect_engine WORKER_MODEL WORKER_ENGINE WORKER_CODEX_MODEL WORKER_CODEX_REASONING
-_auto_detect_engine VERIFIER_MODEL VERIFIER_ENGINE VERIFIER_CODEX_MODEL VERIFIER_CODEX_REASONING
-_auto_detect_engine FINAL_VERIFIER_MODEL FINAL_VERIFIER_ENGINE "" ""
+_auto_detect_engine WORKER_MODEL WORKER_ENGINE WORKER_CODEX_MODEL WORKER_CODEX_REASONING WORKER_EFFORT
+_auto_detect_engine VERIFIER_MODEL VERIFIER_ENGINE VERIFIER_CODEX_MODEL VERIFIER_CODEX_REASONING VERIFIER_EFFORT
+_auto_detect_engine FINAL_VERIFIER_MODEL FINAL_VERIFIER_ENGINE "" "" FINAL_VERIFIER_EFFORT
 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}"
@@ -697,7 +716,8 @@ create_session() {
     "max_nudges": '"$MAX_NUDGES"',
     "cb_threshold": '"$CB_THRESHOLD"',
     "effective_cb_threshold": '"$EFFECTIVE_CB_THRESHOLD"',
-    "with_self_verification": '"$WITH_SELF_VERIFICATION"'
+    "with_self_verification": '"$WITH_SELF_VERIFICATION"',
+    "autonomous_mode": '"$AUTONOMOUS_MODE"'
   }
 }' | atomic_write "$SESSION_CONFIG"
 
@@ -1021,9 +1041,9 @@ restart_worker() {
 
   # Re-launch worker (tmux interactive pattern)
   if [[ "$WORKER_ENGINE" = "codex" ]]; then
-    safe_send_keys "$pane_id" "${CODEX_BIN:-codex} -m $WORKER_CODEX_MODEL -c model_reasoning_effort=\"$WORKER_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\" --disable plugins --dangerously-bypass-approvals-and-sandbox"
   else
-    safe_send_keys "$pane_id" "$(build_claude_cmd tui "$WORKER_MODEL")"
+    safe_send_keys "$pane_id" "$(build_claude_cmd tui "$WORKER_MODEL" "" "" "$WORKER_EFFORT")"
   fi
   WORKER_RESTARTS[$iter]=$((restart_count + 1))
   return 0
@@ -1153,6 +1173,19 @@ write_worker_trigger() {
         echo "- Do NOT signal verify after individual stories"
       fi
     fi
+
+    # Autonomous mode: don't stop on ambiguity, PRD is authoritative
+    if (( AUTONOMOUS_MODE )); then
+      echo ""
+      echo "---"
+      echo "## AUTONOMOUS MODE"
+      echo "Do NOT stop or ask questions when encountering ambiguity or document conflicts."
+      echo "**Resolution priority**: PRD > test-spec > context > memory"
+      echo "If documents disagree, follow PRD and proceed. Log any conflict you find by"
+      echo "appending to \`$LOGS_DIR/conflict-log.jsonl\` in format:"
+      echo '  {"iteration":N,"us_id":"US-NNN","source_a":"prd","source_b":"test-spec","conflict":"description","resolution":"followed PRD"}'
+      echo "Do NOT wait for human input. Keep working."
+    fi
   } | atomic_write "$prompt_file"
 
   # Write trigger script (DO NOT use exec -- breaks heartbeat cleanup)
@@ -1161,12 +1194,12 @@ write_worker_trigger() {
     local engine_cmd="${CODEX_BIN:-codex} \\
   -m $WORKER_CODEX_MODEL \\
   -c model_reasoning_effort=\"$WORKER_CODEX_REASONING\" \\
-  --dangerously-bypass-approvals-and-sandbox \\
+  --disable plugins --dangerously-bypass-approvals-and-sandbox \\
   \"\$(cat $prompt_file)\""
     local engine_comment="# Run codex with fresh context (fallback trigger — TUI primary launch via launch_worker_codex)"
   else
     local engine_cmd
-    engine_cmd=$(build_claude_cmd print "$WORKER_MODEL" "$prompt_file" "$output_log")
+    engine_cmd=$(build_claude_cmd print "$WORKER_MODEL" "$prompt_file" "$output_log" "$WORKER_EFFORT")
     local engine_comment="# Run claude with fresh context, no MCP/skills (governance.md s7 step 5)"
   fi
 
@@ -1239,6 +1272,19 @@ write_verifier_trigger() {
         echo "- **Note**: Skip re-verifying the above US. Focus on unverified stories."
       fi
     fi
+
+    # Autonomous mode: don't stop on ambiguity, PRD is authoritative
+    if (( AUTONOMOUS_MODE )); then
+      echo ""
+      echo "---"
+      echo "## AUTONOMOUS MODE"
+      echo "Do NOT stop or ask questions when encountering ambiguity or document conflicts."
+      echo "**Resolution priority**: PRD > test-spec > context > memory"
+      echo "If documents disagree, follow PRD and proceed. Log any conflict by"
+      echo "appending to \`$LOGS_DIR/conflict-log.jsonl\` in format:"
+      echo '  {"iteration":N,"us_id":"US-NNN","source_a":"prd","source_b":"test-spec","conflict":"description","resolution":"followed PRD"}'
+      echo "Do NOT wait for human input. Keep verifying."
+    fi
   } | atomic_write "$prompt_file"
 
   # Write trigger script (DO NOT use exec -- breaks heartbeat cleanup)
@@ -1246,13 +1292,13 @@ write_verifier_trigger() {
   if [[ "$verifier_engine" = "codex" ]]; then
     local engine_cmd="${CODEX_BIN:-codex} -m $VERIFIER_CODEX_MODEL \\
   -c model_reasoning_effort=\"$VERIFIER_CODEX_REASONING\" \\
-  --dangerously-bypass-approvals-and-sandbox \\
+  --disable plugins --dangerously-bypass-approvals-and-sandbox \\
   \"\$(cat $prompt_file)\" \\
-  2>&1 | tee $output_log"
-    local engine_comment="# Run codex with fresh context (governance.md s7 step 7)"
+  > >(tee $output_log) 2>&1"
+    local engine_comment="# Run codex with fresh context (governance.md s7 step 7) — process substitution preserves tty"
   else
     local engine_cmd
-    engine_cmd=$(build_claude_cmd print "$verifier_model" "$prompt_file" "$output_log")
+    engine_cmd=$(build_claude_cmd print "$verifier_model" "$prompt_file" "$output_log" "$VERIFIER_EFFORT")
     local engine_comment="# Run claude with fresh context, no MCP/skills (governance.md s7 step 7)"
   fi
 
@@ -1652,11 +1698,11 @@ run_single_verifier() {
   # Launch verifier — dispatch to engine-specific function
   local verifier_launch
   if [[ "$engine" = "codex" ]]; then
-    verifier_launch="${CODEX_BIN:-codex} -m $VERIFIER_CODEX_MODEL -c model_reasoning_effort=\"$VERIFIER_CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
+    verifier_launch="${CODEX_BIN:-codex} -m $VERIFIER_CODEX_MODEL -c model_reasoning_effort=\"$VERIFIER_CODEX_REASONING\" --disable plugins --dangerously-bypass-approvals-and-sandbox"
     launch_verifier_codex "$VERIFIER_PANE" "$prompt_file" "$iter" "$verifier_launch"
     log_debug "Verifier$suffix codex TUI dispatched"
   else
-    verifier_launch="$(build_claude_cmd tui "$model")"
+    verifier_launch="$(build_claude_cmd tui "$model" "" "" "$VERIFIER_EFFORT")"
     if ! launch_verifier_claude "$VERIFIER_PANE" "$prompt_file" "$iter" "$verifier_launch"; then
       log_error "Verifier$suffix failed to start"
       return 1
@@ -1666,20 +1712,37 @@ run_single_verifier() {
 
   # Poll for verdict
   if [[ "$engine" = "codex" ]]; then
-    # Codex exec: simple file poll (non-interactive, no heartbeat/nudge needed)
+    # Codex exec: file poll + wait for process exit to avoid reading partial results
     log "  Polling for verify-verdict.json ($suffix, codex TUI)..."
     local codex_poll_start
     codex_poll_start=$(date +%s)
+    local _verdict_detected=0
     while true; do
-      if [[ -f "$VERDICT_FILE" ]]; then
-        # Validate JSON
+      # Phase 1: wait for verdict file
+      if (( ! _verdict_detected )) && [[ -f "$VERDICT_FILE" ]]; then
         if jq . "$VERDICT_FILE" >/dev/null 2>&1; then
-          log "  Verdict file detected: $VERDICT_FILE"
-          break
+          log "  Verdict file detected, waiting for codex process to finish..."
+          _verdict_detected=1
+        fi
+      fi
+      # Phase 2: verdict exists, wait for codex to exit (pane returns to shell)
+      if (( _verdict_detected )); then
+        local _pane_cmd
+        _pane_cmd=$(tmux display-message -p -t "$VERIFIER_PANE" '#{pane_current_command}' 2>/dev/null || echo "")
+        if [[ "$_pane_cmd" = "zsh" || "$_pane_cmd" = "bash" || -z "$_pane_cmd" ]]; then
+          log "  Codex verifier$suffix process exited. Proceeding."
+          # Re-read verdict in case codex updated it before exiting
+          if jq . "$VERDICT_FILE" >/dev/null 2>&1; then
+            break
+          fi
         fi
       fi
       local codex_elapsed=$(( $(date +%s) - codex_poll_start ))
       if (( codex_elapsed >= ITER_TIMEOUT )); then
+        if (( _verdict_detected )); then
+          log "  Codex verifier$suffix timed out waiting for exit, but verdict exists. Proceeding."
+          break
+        fi
         log_error "Codex verifier$suffix timed out after ${ITER_TIMEOUT}s"
         return 1
       fi
@@ -1738,10 +1801,10 @@ run_sequential_final_verify() {
     # Launch verifier
     local verifier_launch
     if [[ "$VERIFIER_ENGINE" = "codex" ]]; then
-      verifier_launch="${CODEX_BIN:-codex} -m $VERIFIER_CODEX_MODEL -c model_reasoning_effort=\"$VERIFIER_CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
+      verifier_launch="${CODEX_BIN:-codex} -m $VERIFIER_CODEX_MODEL -c model_reasoning_effort=\"$VERIFIER_CODEX_REASONING\" --disable plugins --dangerously-bypass-approvals-and-sandbox"
       launch_verifier_codex "$VERIFIER_PANE" "$verifier_prompt" "$iter" "$verifier_launch"
     else
-      verifier_launch="$(build_claude_cmd tui "$VERIFIER_MODEL")"
+      verifier_launch="$(build_claude_cmd tui "$VERIFIER_MODEL" "" "" "$VERIFIER_EFFORT")"
       launch_verifier_claude "$VERIFIER_PANE" "$verifier_prompt" "$iter" "$verifier_launch" || {
         log_error "Failed to launch verifier for $us"
         FAILED_US="$us"
@@ -1752,7 +1815,7 @@ run_sequential_final_verify() {
     # Poll for verdict
     rm -f "$VERDICT_FILE"
     local poll_rc=0
-    poll_for_signal "$VERDICT_FILE" "$ITER_TIMEOUT" "verdict" || poll_rc=$?
+    poll_for_signal "$VERDICT_FILE" "$VERIFIER_HEARTBEAT" "$VERIFIER_PANE" "$verifier_launch" "Verifier-final" || poll_rc=$?
     if (( poll_rc != 0 )); then
       log_error "Verifier poll failed for $us (rc=$poll_rc)"
       FAILED_US="$us"
@@ -2179,14 +2242,14 @@ main() {
 
     local worker_launch
     if [[ "$WORKER_ENGINE" = "codex" ]]; then
-      worker_launch="${CODEX_BIN:-codex} -m $WORKER_CODEX_MODEL -c model_reasoning_effort=\"$WORKER_CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
+      worker_launch="${CODEX_BIN:-codex} -m $WORKER_CODEX_MODEL -c model_reasoning_effort=\"$WORKER_CODEX_REASONING\" --disable plugins --dangerously-bypass-approvals-and-sandbox"
       if ! launch_worker_codex "$WORKER_PANE" "$worker_prompt" "$ITERATION" "$worker_launch"; then
         write_blocked_sentinel "Worker codex failed to start in pane"
         update_status "blocked" "worker_start_failed"
         return 1
       fi
     else
-      worker_launch="$(build_claude_cmd tui "$WORKER_MODEL")"
+      worker_launch="$(build_claude_cmd tui "$WORKER_MODEL" "" "" "$WORKER_EFFORT")"
       if ! launch_worker_claude "$WORKER_PANE" "$worker_prompt" "$ITERATION" "$worker_launch"; then
         write_blocked_sentinel "Worker claude failed to start in pane"
         update_status "blocked" "worker_start_failed"
@@ -2361,9 +2424,9 @@ main() {
 
           local verifier_launch
           if [[ "$VERIFIER_ENGINE" = "codex" ]]; then
-            verifier_launch="${CODEX_BIN:-codex} -m $VERIFIER_CODEX_MODEL -c model_reasoning_effort=\"$VERIFIER_CODEX_REASONING\" --dangerously-bypass-approvals-and-sandbox"
+            verifier_launch="${CODEX_BIN:-codex} -m $VERIFIER_CODEX_MODEL -c model_reasoning_effort=\"$VERIFIER_CODEX_REASONING\" --disable plugins --dangerously-bypass-approvals-and-sandbox"
           else
-            verifier_launch="$(build_claude_cmd tui "$VERIFIER_MODEL")"
+            verifier_launch="$(build_claude_cmd tui "$VERIFIER_MODEL" "" "" "$VERIFIER_EFFORT")"
           fi
           log_debug "[FLOW] iter=$ITERATION phase=verifier engine=$VERIFIER_ENGINE model=$VERIFIER_MODEL scope=${signal_us_id:-all} dispatched=true"
 
@@ -2610,6 +2673,8 @@ while (( _cli_i <= $# )); do
       if [[ "$WORKER_ENGINE" = "codex" ]]; then
         WORKER_CODEX_MODEL="$WORKER_MODEL"
         WORKER_CODEX_REASONING="${_cli_rest##* }"
+      elif [[ "$_cli_rest" == *" "* ]]; then
+        WORKER_EFFORT="${_cli_rest##* }"
       fi
       ;;
     --verifier-model)
@@ -2621,11 +2686,16 @@ while (( _cli_i <= $# )); do
       if [[ "$VERIFIER_ENGINE" = "codex" ]]; then
         VERIFIER_CODEX_MODEL="$VERIFIER_MODEL"
         VERIFIER_CODEX_REASONING="${_cli_rest##* }"
+      elif [[ "$_cli_rest" == *" "* ]]; then
+        VERIFIER_EFFORT="${_cli_rest##* }"
       fi
       ;;
     --lock-worker-model)
       LOCK_WORKER_MODEL=1
       ;;
+    --autonomous)
+      AUTONOMOUS_MODE=1
+      ;;
     --final-verifier-model)
       (( _cli_i++ ))
       _cli_parsed=$(parse_model_flag "${@[$_cli_i]:-}" "final-verifier") || exit 1
@@ -2635,6 +2705,8 @@ while (( _cli_i <= $# )); do
       if [[ "$FINAL_VERIFIER_ENGINE" = "codex" ]]; then
         FINAL_VERIFIER_CODEX_MODEL="$FINAL_VERIFIER_MODEL"
         FINAL_VERIFIER_CODEX_REASONING="${_cli_rest##* }"
+      elif [[ "$_cli_rest" == *" "* ]]; then
+        FINAL_VERIFIER_EFFORT="${_cli_rest##* }"
       fi
       ;;
     --consensus)