bmalph 2.7.6 → 2.7.7

package/ralph/lib/response_analyzer.sh

@@ -396,6 +396,68 @@ trim_shell_whitespace() {
     printf '%s' "$value"
 }
 
+extract_ralph_status_block_json() {
+    local text=$1
+    local normalized="${text//$'\r'/}"
+
+    if [[ "$normalized" != *"---RALPH_STATUS---"* ]]; then
+        return 1
+    fi
+
+    local block="${normalized#*---RALPH_STATUS---}"
+    if [[ "$block" == "$normalized" ]]; then
+        return 1
+    fi
+
+    if [[ "$block" == *"---END_RALPH_STATUS---"* ]]; then
+        block="${block%%---END_RALPH_STATUS---*}"
+    fi
+
+    local status=""
+    local exit_signal="false"
+    local exit_signal_found="false"
+    local tasks_completed_this_loop=0
+    local line=""
+    local trimmed=""
+    local value=""
+
+    while IFS= read -r line; do
+        trimmed=$(trim_shell_whitespace "$line")
+
+        case "$trimmed" in
+            STATUS:*)
+                value=$(trim_shell_whitespace "${trimmed#STATUS:}")
+                [[ -n "$value" ]] && status="$value"
+                ;;
+            EXIT_SIGNAL:*)
+                value=$(trim_shell_whitespace "${trimmed#EXIT_SIGNAL:}")
+                if [[ "$value" == "true" || "$value" == "false" ]]; then
+                    exit_signal="$value"
+                    exit_signal_found="true"
+                fi
+                ;;
+            TASKS_COMPLETED_THIS_LOOP:*)
+                value=$(trim_shell_whitespace "${trimmed#TASKS_COMPLETED_THIS_LOOP:}")
+                if [[ "$value" =~ ^-?[0-9]+$ ]]; then
+                    tasks_completed_this_loop=$value
+                fi
+                ;;
+        esac
+    done <<< "$block"
+
+    jq -n \
+        --arg status "$status" \
+        --argjson exit_signal_found "$exit_signal_found" \
+        --argjson exit_signal "$exit_signal" \
+        --argjson tasks_completed_this_loop "$tasks_completed_this_loop" \
+        '{
+            status: $status,
+            exit_signal_found: $exit_signal_found,
+            exit_signal: $exit_signal,
+            tasks_completed_this_loop: $tasks_completed_this_loop
+        }'
+}
+
 # Parse JSON response and extract structured fields
 # Creates .ralph/.json_parse_result with normalized analysis data
 # Supports FIVE JSON formats:
@@ -466,35 +528,38 @@ parse_json_response() {
     # Track whether EXIT_SIGNAL was explicitly provided (vs inferred from STATUS)
     local exit_signal=$(jq -r -j '.exit_signal // false' "$output_file" 2>/dev/null)
     local explicit_exit_signal_found=$(jq -r -j 'has("exit_signal")' "$output_file" 2>/dev/null)
+    local tasks_completed_this_loop=$(jq -r -j '.tasks_completed_this_loop // 0' "$output_file" 2>/dev/null)
+    if [[ ! "$tasks_completed_this_loop" =~ ^-?[0-9]+$ ]]; then
+        tasks_completed_this_loop=0
+    fi
 
-    # Bug #1 Fix: If exit_signal is still false, check for RALPH_STATUS block in .result field
-    # Claude CLI JSON format embeds the RALPH_STATUS block within the .result text field
-    if [[ "$exit_signal" == "false" && "$has_result_field" == "true" ]]; then
-        local result_text=$(jq -r -j '.result // ""' "$output_file" 2>/dev/null)
-        if [[ -n "$result_text" ]] && echo "$result_text" | grep -q -- "---RALPH_STATUS---"; then
-            # Extract EXIT_SIGNAL value from RALPH_STATUS block within result text
-            local embedded_exit_sig
-            embedded_exit_sig=$(trim_shell_whitespace "$(printf '%s\n' "$result_text" | grep "EXIT_SIGNAL:" | cut -d: -f2)")
-            if [[ -n "$embedded_exit_sig" ]]; then
-                # Explicit EXIT_SIGNAL found in RALPH_STATUS block
-                explicit_exit_signal_found="true"
-                if [[ "$embedded_exit_sig" == "true" ]]; then
-                    exit_signal="true"
-                    [[ "${VERBOSE_PROGRESS:-}" == "true" ]] && echo "DEBUG: Extracted EXIT_SIGNAL=true from .result RALPH_STATUS block" >&2
-                else
-                    exit_signal="false"
-                    [[ "${VERBOSE_PROGRESS:-}" == "true" ]] && echo "DEBUG: Extracted EXIT_SIGNAL=false from .result RALPH_STATUS block (respecting explicit intent)" >&2
-                fi
-            fi
-            # Also check STATUS field as fallback ONLY when EXIT_SIGNAL was not specified
-            # This respects explicit EXIT_SIGNAL: false which means "task complete, continue working"
-            local embedded_status
-            embedded_status=$(trim_shell_whitespace "$(printf '%s\n' "$result_text" | grep "STATUS:" | cut -d: -f2)")
-            if [[ "$embedded_status" == "COMPLETE" && "$explicit_exit_signal_found" != "true" ]]; then
-                # STATUS: COMPLETE without any EXIT_SIGNAL field implies completion
-                exit_signal="true"
-                [[ "${VERBOSE_PROGRESS:-}" == "true" ]] && echo "DEBUG: Inferred EXIT_SIGNAL=true from .result STATUS=COMPLETE (no explicit EXIT_SIGNAL found)" >&2
-            fi
+    local result_text=""
+    if [[ "$has_result_field" == "true" ]]; then
+        result_text=$(jq -r -j '.result // ""' "$output_file" 2>/dev/null)
+    fi
+
+    local ralph_status_json=""
+    if [[ -n "$result_text" ]] && ralph_status_json=$(extract_ralph_status_block_json "$result_text" 2>/dev/null); then
+        local embedded_exit_signal_found
+        embedded_exit_signal_found=$(printf '%s' "$ralph_status_json" | jq -r -j '.exit_signal_found' 2>/dev/null)
+        local embedded_exit_sig
+        embedded_exit_sig=$(printf '%s' "$ralph_status_json" | jq -r -j '.exit_signal' 2>/dev/null)
+        local embedded_status
+        embedded_status=$(printf '%s' "$ralph_status_json" | jq -r -j '.status' 2>/dev/null)
+        local embedded_tasks_completed
+        embedded_tasks_completed=$(printf '%s' "$ralph_status_json" | jq -r -j '.tasks_completed_this_loop' 2>/dev/null)
+
+        if [[ "$embedded_tasks_completed" =~ ^-?[0-9]+$ ]]; then
+            tasks_completed_this_loop=$embedded_tasks_completed
+        fi
+
+        if [[ "$embedded_exit_signal_found" == "true" ]]; then
+            explicit_exit_signal_found="true"
+            exit_signal="$embedded_exit_sig"
+            [[ "${VERBOSE_PROGRESS:-}" == "true" ]] && echo "DEBUG: Extracted EXIT_SIGNAL=$embedded_exit_sig from .result RALPH_STATUS block" >&2
+        elif [[ "$embedded_status" == "COMPLETE" && "$explicit_exit_signal_found" != "true" ]]; then
+            exit_signal="true"
+            [[ "${VERBOSE_PROGRESS:-}" == "true" ]] && echo "DEBUG: Inferred EXIT_SIGNAL=true from .result STATUS=COMPLETE (no explicit EXIT_SIGNAL found)" >&2
         fi
     fi
 
@@ -640,6 +705,7 @@ parse_json_response() {
         --argjson loop_number "$loop_number" \
         --arg session_id "$session_id" \
         --argjson confidence "$confidence" \
+        --argjson tasks_completed_this_loop "$tasks_completed_this_loop" \
         --argjson has_permission_denials "$has_permission_denials" \
         --argjson permission_denial_count "$permission_denial_count" \
         --argjson denied_commands "$denied_commands_json" \
@@ -655,6 +721,7 @@ parse_json_response() {
             loop_number: $loop_number,
             session_id: $session_id,
             confidence: $confidence,
+            tasks_completed_this_loop: $tasks_completed_this_loop,
             has_permission_denials: $has_permission_denials,
             permission_denial_count: $permission_denial_count,
             denied_commands: $denied_commands,
@@ -687,6 +754,7 @@ analyze_response() {
     local exit_signal=false
     local work_summary=""
     local files_modified=0
+    local tasks_completed_this_loop=0
 
     # Read output file
     if [[ ! -f "$output_file" ]]; then
@@ -712,6 +780,7 @@ analyze_response() {
             is_stuck=$(jq -r -j '.is_stuck' "$json_parse_result_file" 2>/dev/null || echo "false")
             work_summary=$(jq -r -j '.summary' "$json_parse_result_file" 2>/dev/null || echo "")
             files_modified=$(jq -r -j '.files_modified' "$json_parse_result_file" 2>/dev/null || echo "0")
+            tasks_completed_this_loop=$(jq -r -j '.tasks_completed_this_loop // 0' "$json_parse_result_file" 2>/dev/null || echo "0")
             local json_confidence=$(jq -r -j '.confidence' "$json_parse_result_file" 2>/dev/null || echo "0")
             local session_id=$(jq -r -j '.session_id' "$json_parse_result_file" 2>/dev/null || echo "")
 
@@ -733,6 +802,10 @@ analyze_response() {
                 confidence_score=$((json_confidence + 50))
             fi
 
+            if [[ ! "$tasks_completed_this_loop" =~ ^-?[0-9]+$ ]]; then
+                tasks_completed_this_loop=0
+            fi
+
             # Check for file changes via git (supplements JSON data)
             # Fix #141: Detect both uncommitted changes AND committed changes
             if command -v git &>/dev/null && git rev-parse --git-dir >/dev/null 2>&1; then
@@ -784,6 +857,7 @@ analyze_response() {
                 --argjson files_modified "$files_modified" \
                 --argjson confidence_score "$confidence_score" \
                 --argjson exit_signal "$exit_signal" \
+                --argjson tasks_completed_this_loop "$tasks_completed_this_loop" \
                 --arg work_summary "$work_summary" \
                 --argjson output_length "$output_length" \
                 --argjson has_permission_denials "$has_permission_denials" \
@@ -802,6 +876,9 @@ analyze_response() {
                         files_modified: $files_modified,
                         confidence_score: $confidence_score,
                         exit_signal: $exit_signal,
+                        tasks_completed_this_loop: $tasks_completed_this_loop,
+                        fix_plan_completed_delta: 0,
+                        has_progress_tracking_mismatch: false,
                         work_summary: $work_summary,
                         output_length: $output_length,
                         has_permission_denials: $has_permission_denials,
@@ -823,13 +900,23 @@ analyze_response() {
     local explicit_exit_signal_found=false
 
     # 1. Check for explicit structured output (if Claude follows schema)
-    if grep -q -- "---RALPH_STATUS---" "$output_file"; then
-        # Parse structured output
-        local status=$(trim_shell_whitespace "$(grep "STATUS:" "$output_file" | cut -d: -f2)")
-        local exit_sig=$(trim_shell_whitespace "$(grep "EXIT_SIGNAL:" "$output_file" | cut -d: -f2)")
+    local ralph_status_json=""
+    if ralph_status_json=$(extract_ralph_status_block_json "$output_content" 2>/dev/null); then
+        local status
+        status=$(printf '%s' "$ralph_status_json" | jq -r -j '.status' 2>/dev/null)
+        local exit_sig_found
+        exit_sig_found=$(printf '%s' "$ralph_status_json" | jq -r -j '.exit_signal_found' 2>/dev/null)
+        local exit_sig
+        exit_sig=$(printf '%s' "$ralph_status_json" | jq -r -j '.exit_signal' 2>/dev/null)
+        local parsed_tasks_completed
+        parsed_tasks_completed=$(printf '%s' "$ralph_status_json" | jq -r -j '.tasks_completed_this_loop' 2>/dev/null)
+
+        if [[ "$parsed_tasks_completed" =~ ^-?[0-9]+$ ]]; then
+            tasks_completed_this_loop=$parsed_tasks_completed
+        fi
 
         # If EXIT_SIGNAL is explicitly provided, respect it
-        if [[ -n "$exit_sig" ]]; then
+        if [[ "$exit_sig_found" == "true" ]]; then
             explicit_exit_signal_found=true
             if [[ "$exit_sig" == "true" ]]; then
                 has_completion_signal=true
@@ -1002,6 +1089,7 @@ analyze_response() {
         --argjson files_modified "$files_modified" \
         --argjson confidence_score "$confidence_score" \
         --argjson exit_signal "$exit_signal" \
+        --argjson tasks_completed_this_loop "$tasks_completed_this_loop" \
         --arg work_summary "$work_summary" \
         --argjson output_length "$output_length" \
         --argjson has_permission_denials "$has_permission_denials" \
@@ -1020,6 +1108,9 @@ analyze_response() {
                 files_modified: $files_modified,
                 confidence_score: $confidence_score,
                 exit_signal: $exit_signal,
+                tasks_completed_this_loop: $tasks_completed_this_loop,
+                fix_plan_completed_delta: 0,
+                has_progress_tracking_mismatch: false,
                 work_summary: $work_summary,
                 output_length: $output_length,
                 has_permission_denials: $has_permission_denials,
@@ -1049,6 +1140,7 @@ update_exit_signals() {
     local loop_number=$(jq -r -j '.loop_number' "$analysis_file")
     local has_progress=$(jq -r -j '.analysis.has_progress' "$analysis_file")
     local has_permission_denials=$(jq -r -j '.analysis.has_permission_denials // false' "$analysis_file")
+    local has_progress_tracking_mismatch=$(jq -r -j '.analysis.has_progress_tracking_mismatch // false' "$analysis_file")
 
     # Read current exit signals
     local signals=$(cat "$exit_signals_file" 2>/dev/null || echo '{"test_only_loops": [], "done_signals": [], "completion_indicators": []}')
@@ -1065,7 +1157,7 @@ update_exit_signals() {
 
     # Permission denials are handled in the same loop, so they must not become
     # completion state that can halt the next loop.
-    if [[ "$has_permission_denials" != "true" && "$has_completion_signal" == "true" ]]; then
+    if [[ "$has_permission_denials" != "true" && "$has_progress_tracking_mismatch" != "true" && "$has_completion_signal" == "true" ]]; then
         signals=$(echo "$signals" | jq ".done_signals += [$loop_number]")
     fi
 
@@ -1074,7 +1166,7 @@ update_exit_signals() {
     # due to deterministic scoring (+50 for JSON format, +20 for result field).
     # This caused premature exits after 5 loops. Now we respect Claude's explicit intent.
     local exit_signal=$(jq -r -j '.analysis.exit_signal // false' "$analysis_file")
-    if [[ "$has_permission_denials" != "true" && "$exit_signal" == "true" ]]; then
+    if [[ "$has_permission_denials" != "true" && "$has_progress_tracking_mismatch" != "true" && "$exit_signal" == "true" ]]; then
         signals=$(echo "$signals" | jq ".completion_indicators += [$loop_number]")
     fi
 

package/ralph/ralph_import.sh

@@ -353,9 +353,17 @@ You are Ralph, an autonomous AI development agent working on a [PROJECT NAME] pr
 - Search the codebase before assuming something isn't implemented
 - Use subagents for expensive operations (file searching, analysis)
 - Write comprehensive tests with clear documentation
-- Update @fix_plan.md with your learnings
+- Toggle completed story checkboxes in @fix_plan.md without rewriting story lines
 - Commit working changes with descriptive messages
 
+## Progress Tracking (CRITICAL)
+- Ralph tracks progress by counting story checkboxes in @fix_plan.md
+- When you complete a story, change `- [ ]` to `- [x]` on that exact story line
+- Do NOT remove, rewrite, or reorder story lines in @fix_plan.md
+- Update the checkbox before committing so the monitor updates immediately
+- Set `TASKS_COMPLETED_THIS_LOOP` to the exact number of story checkboxes toggled this loop
+- Only valid values: 0 or 1
+
 ## 🧪 Testing Guidelines (CRITICAL)
 - LIMIT testing to ~20% of your total effort per loop
 - PRIORITIZE: Implementation > Documentation > Tests

package/ralph/ralph_loop.sh

@@ -73,13 +73,13 @@ _env_CB_AUTO_RESET="${CB_AUTO_RESET:-}"
 MAX_CALLS_PER_HOUR="${MAX_CALLS_PER_HOUR:-100}"
 VERBOSE_PROGRESS="${VERBOSE_PROGRESS:-false}"
 CLAUDE_TIMEOUT_MINUTES="${CLAUDE_TIMEOUT_MINUTES:-15}"
-DEFAULT_CLAUDE_ALLOWED_TOOLS="Write,Read,Edit,MultiEdit,Glob,Grep,Task,TodoWrite,WebFetch,WebSearch,NotebookEdit,Bash"
+DEFAULT_CLAUDE_ALLOWED_TOOLS="Write,Read,Edit,MultiEdit,Glob,Grep,Task,TodoWrite,WebFetch,WebSearch,EnterPlanMode,ExitPlanMode,NotebookEdit,Bash"
 DEFAULT_PERMISSION_DENIAL_MODE="continue"
 
 # Modern Claude CLI configuration (Phase 1.1)
 CLAUDE_OUTPUT_FORMAT="${CLAUDE_OUTPUT_FORMAT:-json}"
 CLAUDE_ALLOWED_TOOLS="${CLAUDE_ALLOWED_TOOLS:-$DEFAULT_CLAUDE_ALLOWED_TOOLS}"
-CLAUDE_PERMISSION_MODE="${CLAUDE_PERMISSION_MODE:-auto}"
+CLAUDE_PERMISSION_MODE="${CLAUDE_PERMISSION_MODE:-bypassPermissions}"
 CLAUDE_USE_CONTINUE="${CLAUDE_USE_CONTINUE:-true}"
 PERMISSION_DENIAL_MODE="${PERMISSION_DENIAL_MODE:-$DEFAULT_PERMISSION_DENIAL_MODE}"
 CLAUDE_SESSION_FILE="$RALPH_DIR/.claude_session_id" # Session ID persistence file
@@ -108,6 +108,8 @@ VALID_TOOL_PATTERNS=(
     "WebFetch"
     "WebSearch"
     "AskUserQuestion"
+    "EnterPlanMode"
+    "ExitPlanMode"
     "Bash"
     "Bash(git *)"
     "Bash(npm *)"
@@ -249,7 +251,7 @@ driver_supports_tool_allowlist() {
 driver_permission_denial_help() {
     echo "  - Review the active driver's permission or approval settings."
     echo "  - ALLOWED_TOOLS in $RALPHRC_FILE only applies to the Claude Code driver."
-    echo "  - Keep CLAUDE_PERMISSION_MODE=auto for unattended Claude Code loops."
+    echo "  - Keep CLAUDE_PERMISSION_MODE=bypassPermissions for unattended Claude Code loops."
     echo "  - After updating permissions, reset the session and restart the loop."
 }
 
@@ -530,7 +532,7 @@ validate_permission_denial_mode() {
 
 normalize_claude_permission_mode() {
     if [[ -z "${CLAUDE_PERMISSION_MODE:-}" ]]; then
-        CLAUDE_PERMISSION_MODE="auto"
+        CLAUDE_PERMISSION_MODE="bypassPermissions"
     fi
 }
 
@@ -726,6 +728,74 @@ wait_for_reset() {
     log_status "SUCCESS" "Rate limit reset! Ready for new calls."
 }
 
+count_fix_plan_checkboxes() {
+    local fix_plan_file="${1:-$RALPH_DIR/@fix_plan.md}"
+    local completed_items=0
+    local uncompleted_items=0
+    local total_items=0
+
+    if [[ -f "$fix_plan_file" ]]; then
+        uncompleted_items=$(grep -cE "^[[:space:]]*- \[ \]" "$fix_plan_file" 2>/dev/null || true)
+        [[ -z "$uncompleted_items" ]] && uncompleted_items=0
+        completed_items=$(grep -cE "^[[:space:]]*- \[[xX]\]" "$fix_plan_file" 2>/dev/null || true)
+        [[ -z "$completed_items" ]] && completed_items=0
+    fi
+
+    total_items=$((completed_items + uncompleted_items))
+    printf '%s %s %s\n' "$completed_items" "$uncompleted_items" "$total_items"
+}
+
+enforce_fix_plan_progress_tracking() {
+    local analysis_file=$1
+    local completed_before=$2
+    local completed_after=$3
+
+    if [[ ! -f "$analysis_file" ]]; then
+        return 0
+    fi
+
+    local claimed_tasks
+    claimed_tasks=$(jq -r '.analysis.tasks_completed_this_loop // 0' "$analysis_file" 2>/dev/null || echo "0")
+    if [[ ! "$claimed_tasks" =~ ^-?[0-9]+$ ]]; then
+        claimed_tasks=0
+    fi
+
+    local fix_plan_completed_delta=$((completed_after - completed_before))
+    local has_progress_tracking_mismatch=false
+    if [[ $claimed_tasks -ne $fix_plan_completed_delta || $claimed_tasks -gt 1 || $fix_plan_completed_delta -gt 1 || $fix_plan_completed_delta -lt 0 ]]; then
+        has_progress_tracking_mismatch=true
+    fi
+
+    local tmp_file="$analysis_file.tmp"
+    if jq \
+        --argjson claimed_tasks "$claimed_tasks" \
+        --argjson fix_plan_completed_delta "$fix_plan_completed_delta" \
+        --argjson has_progress_tracking_mismatch "$has_progress_tracking_mismatch" \
+        '
+            (.analysis //= {}) |
+            .analysis.tasks_completed_this_loop = $claimed_tasks |
+            .analysis.fix_plan_completed_delta = $fix_plan_completed_delta |
+            .analysis.has_progress_tracking_mismatch = $has_progress_tracking_mismatch |
+            if $has_progress_tracking_mismatch then
+                .analysis.has_completion_signal = false |
+                .analysis.exit_signal = false
+            else
+                .
+            end
+        ' "$analysis_file" > "$tmp_file" 2>/dev/null; then
+        mv "$tmp_file" "$analysis_file"
+    else
+        rm -f "$tmp_file" 2>/dev/null
+        return 0
+    fi
+
+    if [[ "$has_progress_tracking_mismatch" == "true" ]]; then
+        log_status "WARN" "Progress tracking mismatch: claimed $claimed_tasks completed task(s) but checkbox delta was $fix_plan_completed_delta. Completion signals suppressed for this loop."
+    fi
+
+    return 0
+}
+
 # Check if we should gracefully exit
 should_exit_gracefully() {
     
@@ -792,11 +862,10 @@ should_exit_gracefully() {
     # Fix #144: Only match valid markdown checkboxes, not date entries like [2026-01-29]
     # Valid patterns: "- [ ]" (uncompleted) and "- [x]" or "- [X]" (completed)
     if [[ -f "$RALPH_DIR/@fix_plan.md" ]]; then
-        local uncompleted_items=$(grep -cE "^[[:space:]]*- \[ \]" "$RALPH_DIR/@fix_plan.md" 2>/dev/null || true)
-        [[ -z "$uncompleted_items" ]] && uncompleted_items=0
-        local completed_items=$(grep -cE "^[[:space:]]*- \[[xX]\]" "$RALPH_DIR/@fix_plan.md" 2>/dev/null || true)
-        [[ -z "$completed_items" ]] && completed_items=0
-        local total_items=$((uncompleted_items + completed_items))
+        local completed_items=0
+        local uncompleted_items=0
+        local total_items=0
+        read -r completed_items uncompleted_items total_items < <(count_fix_plan_checkboxes "$RALPH_DIR/@fix_plan.md")
 
         if [[ $total_items -gt 0 ]] && [[ $completed_items -eq $total_items ]]; then
             log_status "WARN" "Exit condition: All @fix_plan.md items completed ($completed_items/$total_items)" >&2
@@ -901,8 +970,10 @@ build_loop_context() {
     # Extract incomplete tasks from @fix_plan.md
     # Bug #3 Fix: Support indented markdown checkboxes with [[:space:]]* pattern
     if [[ -f "$RALPH_DIR/@fix_plan.md" ]]; then
-        local incomplete_tasks=$(grep -cE "^[[:space:]]*- \[ \]" "$RALPH_DIR/@fix_plan.md" 2>/dev/null || true)
-        [[ -z "$incomplete_tasks" ]] && incomplete_tasks=0
+        local completed_tasks=0
+        local incomplete_tasks=0
+        local total_tasks=0
+        read -r completed_tasks incomplete_tasks total_tasks < <(count_fix_plan_checkboxes "$RALPH_DIR/@fix_plan.md")
         context+="Remaining tasks: ${incomplete_tasks}. "
     fi
 
@@ -1410,6 +1481,8 @@ execute_claude_code() {
     local loop_count=$1
     local calls_made=$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")
     calls_made=$((calls_made + 1))
+    local fix_plan_completed_before=0
+    read -r fix_plan_completed_before _ _ < <(count_fix_plan_checkboxes "$RALPH_DIR/@fix_plan.md")
 
     # Fix #141: Capture git HEAD SHA at loop start to detect commits as progress
     # Store in file for access by progress detection after Claude execution
@@ -1664,6 +1737,10 @@ EOF
         analyze_response "$output_file" "$loop_count"
         local analysis_exit_code=$?
 
+        local fix_plan_completed_after=0
+        read -r fix_plan_completed_after _ _ < <(count_fix_plan_checkboxes "$RALPH_DIR/@fix_plan.md")
+        enforce_fix_plan_progress_tracking "$RESPONSE_ANALYSIS_FILE" "$fix_plan_completed_before" "$fix_plan_completed_after"
+
         # Update exit signals based on analysis
         update_exit_signals
 

package/ralph/templates/PROMPT.md

@@ -9,16 +9,24 @@ You are Ralph, an autonomous AI development agent working on a [YOUR PROJECT NAM
 3. Implement the highest priority item using best practices
 4. Use parallel subagents for complex tasks (max 100 concurrent)
 5. Run tests after each implementation
-6. Update documentation and @fix_plan.md
+6. Update documentation and the completed story checkbox in @fix_plan.md
 
 ## Key Principles
 - ONE task per loop - focus on the most important thing
 - Search the codebase before assuming something isn't implemented
 - Use subagents for expensive operations (file searching, analysis)
 - Write comprehensive tests with clear documentation
-- Update .ralph/@fix_plan.md with your learnings
+- Toggle completed story checkboxes in .ralph/@fix_plan.md without rewriting story lines
 - Commit working changes with descriptive messages
 
+## Progress Tracking (CRITICAL)
+- Ralph tracks progress by counting story checkboxes in .ralph/@fix_plan.md
+- When you complete a story, change `- [ ]` to `- [x]` on that exact story line
+- Do NOT remove, rewrite, or reorder story lines in .ralph/@fix_plan.md
+- Update the checkbox before committing so the monitor updates immediately
+- Set `TASKS_COMPLETED_THIS_LOOP` to the exact number of story checkboxes toggled this loop
+- Only valid values: 0 or 1
+
 ## 🧪 Testing Guidelines (CRITICAL)
 - LIMIT testing to ~20% of your total effort per loop
 - PRIORITIZE: Implementation > Documentation > Tests
@@ -34,6 +42,8 @@ You are Ralph, an autonomous AI development agent working on a [YOUR PROJECT NAM
 - Keep .ralph/@AGENT.md updated with build/run instructions
 - Document the WHY behind tests and implementations
 - No placeholder implementations - build it properly
+
+## Autonomous Mode (CRITICAL)
 - do not ask the user questions during loop execution
 - do not use AskUserQuestion, EnterPlanMode, or ExitPlanMode during loop execution
 - make the safest reasonable assumption and continue
@@ -47,7 +57,7 @@ You are Ralph, an autonomous AI development agent working on a [YOUR PROJECT NAM
 ```
 ---RALPH_STATUS---
 STATUS: IN_PROGRESS | COMPLETE | BLOCKED
-TASKS_COMPLETED_THIS_LOOP: <number>
+TASKS_COMPLETED_THIS_LOOP: 0 | 1
 FILES_MODIFIED: <number>
 TESTS_STATUS: PASSING | FAILING | NOT_RUN
 WORK_TYPE: IMPLEMENTATION | TESTING | DOCUMENTATION | REFACTORING
@@ -71,7 +81,7 @@ Set EXIT_SIGNAL to **true** when ALL of these conditions are met:
 ```
 ---RALPH_STATUS---
 STATUS: IN_PROGRESS
-TASKS_COMPLETED_THIS_LOOP: 2
+TASKS_COMPLETED_THIS_LOOP: 1
 FILES_MODIFIED: 5
 TESTS_STATUS: PASSING
 WORK_TYPE: IMPLEMENTATION
@@ -234,7 +244,7 @@ RECOMMENDATION: No remaining work, all .ralph/specs implemented
 ```
 ---RALPH_STATUS---
 STATUS: IN_PROGRESS
-TASKS_COMPLETED_THIS_LOOP: 3
+TASKS_COMPLETED_THIS_LOOP: 1
 FILES_MODIFIED: 7
 TESTS_STATUS: PASSING
 WORK_TYPE: IMPLEMENTATION

package/ralph/templates/ralphrc.template

@@ -43,11 +43,11 @@ CLAUDE_OUTPUT_FORMAT="json"
 # Comma-separated list of allowed tools for Claude Code only.
 # Ignored by the codex, cursor, and copilot drivers.
 # Opt in to interactive pauses by adding AskUserQuestion manually.
-ALLOWED_TOOLS="Write,Read,Edit,MultiEdit,Glob,Grep,Task,TodoWrite,WebFetch,WebSearch,NotebookEdit,Bash"
+ALLOWED_TOOLS="Write,Read,Edit,MultiEdit,Glob,Grep,Task,TodoWrite,WebFetch,WebSearch,EnterPlanMode,ExitPlanMode,NotebookEdit,Bash"
 
-# Permission mode for Claude Code CLI (default: auto)
+# Permission mode for Claude Code CLI (default: bypassPermissions)
 # Options: auto, acceptEdits, bypassPermissions, default, dontAsk, plan
-CLAUDE_PERMISSION_MODE="auto"
+CLAUDE_PERMISSION_MODE="bypassPermissions"
 
 # How Ralph responds when a driver reports permission denials:
 # - continue: log the denial and keep looping (default for unattended mode)