bmalph 2.7.5 → 2.7.7

package/ralph/lib/response_analyzer.sh

@@ -22,6 +22,103 @@ RALPH_DIR="${RALPH_DIR:-.ralph}"
 COMPLETION_KEYWORDS=("done" "complete" "finished" "all tasks complete" "project complete" "ready for review")
 TEST_ONLY_PATTERNS=("npm test" "bats" "pytest" "jest" "cargo test" "go test" "running tests")
 NO_WORK_PATTERNS=("nothing to do" "no changes" "already implemented" "up to date")
+PERMISSION_DENIAL_INLINE_PATTERNS=(
+    "requires approval before it can run"
+    "requires approval before it can proceed"
+    "not allowed to use tool"
+    "not permitted to use tool"
+)
+
+extract_permission_signal_text() {
+    local text=$1
+
+    if [[ -z "$text" ]]; then
+        echo ""
+        return 0
+    fi
+
+    # Only inspect the response preamble for tool refusals. Later paragraphs and
+    # copied logs often contain old permission errors that should not halt Ralph.
+    local signal_source="${text//$'\r'/}"
+    if [[ "$signal_source" == *"---RALPH_STATUS---"* ]]; then
+        signal_source="${signal_source%%---RALPH_STATUS---*}"
+    fi
+
+    local signal_text=""
+    local non_empty_lines=0
+    local trimmed=""
+    local line=""
+
+    while IFS= read -r line; do
+        trimmed="${line#"${line%%[![:space:]]*}"}"
+        trimmed="${trimmed%"${trimmed##*[![:space:]]}"}"
+
+        if [[ -z "$trimmed" ]]; then
+            if [[ $non_empty_lines -gt 0 ]]; then
+                break
+            fi
+            continue
+        fi
+
+        signal_text+="$trimmed"$'\n'
+        ((non_empty_lines += 1))
+        if [[ $non_empty_lines -ge 5 ]]; then
+            break
+        fi
+    done <<< "$signal_source"
+
+    printf '%s' "$signal_text"
+}
+
+permission_denial_line_matches() {
+    local normalized=$1
+
+    case "$normalized" in
+        permission\ denied:*|denied\ permission:*)
+            [[ "$normalized" == *approval* || "$normalized" == *tool* || "$normalized" == *command* || "$normalized" == *blocked* || "$normalized" == *"not allowed"* || "$normalized" == *"not permitted"* ]]
+            return
+            ;;
+        approval\ required:*)
+            [[ "$normalized" == *run* || "$normalized" == *proceed* || "$normalized" == *tool* || "$normalized" == *command* || "$normalized" == *blocked* ]]
+            return
+            ;;
+    esac
+
+    return 1
+}
+
+contains_permission_denial_signal() {
+    local signal_text=$1
+
+    if [[ -z "$signal_text" ]]; then
+        return 1
+    fi
+
+    local line
+    while IFS= read -r line; do
+        local trimmed="${line#"${line%%[![:space:]]*}"}"
+        local normalized="${trimmed,,}"
+
+        if permission_denial_line_matches "$normalized"; then
+            return 0
+        fi
+
+        local pattern
+        for pattern in "${PERMISSION_DENIAL_INLINE_PATTERNS[@]}"; do
+            if [[ "$normalized" == *"$pattern"* ]]; then
+                return 0
+            fi
+        done
+    done <<< "$signal_text"
+
+    return 1
+}
+
+contains_permission_denial_text() {
+    local signal_text
+    signal_text=$(extract_permission_signal_text "$1")
+    contains_permission_denial_signal "$signal_text"
+}
 
 # =============================================================================
 # JSON OUTPUT FORMAT DETECTION AND PARSING
@@ -299,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:
@@ -369,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
 
@@ -452,6 +614,14 @@ parse_json_response() {
         denied_commands_json=$(jq -r -j '[.permission_denials[] | if .tool_name == "Bash" then "Bash(\(.tool_input.command // "?" | split("\n")[0] | .[0:60]))" else .tool_name // "unknown" end]' "$output_file" 2>/dev/null || echo "[]")
     fi
 
+    # Heuristic permission-denial matching is limited to the refusal-shaped
+    # response preamble, not arbitrary prose or copied logs later in the body.
+    if [[ "$has_permission_denials" != "true" ]] && contains_permission_denial_text "$summary"; then
+        has_permission_denials="true"
+        permission_denial_count=1
+        denied_commands_json='["permission_denied"]'
+    fi
+
     # Apply completion heuristics to normalized summary text when explicit structured
     # completion markers are absent. This keeps JSONL analysis aligned with text mode.
     local summary_has_completion_keyword="false"
@@ -535,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" \
@@ -550,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,
@@ -582,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
@@ -607,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 "")
 
@@ -628,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
@@ -679,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" \
@@ -697,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,
@@ -718,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
@@ -873,8 +1065,18 @@ analyze_response() {
         fi
     fi
 
+    local has_permission_denials=false
+    local permission_denial_count=0
+    local denied_commands_json='[]'
+    local permission_signal_text=""
+    permission_signal_text=$(extract_permission_signal_text "$output_content")
+    if contains_permission_denial_text "$work_summary" || contains_permission_denial_signal "$permission_signal_text"; then
+        has_permission_denials=true
+        permission_denial_count=1
+        denied_commands_json='["permission_denied"]'
+    fi
+
     # Write analysis results to file (text parsing path) using jq for safe construction
-    # Note: Permission denial fields default to false/0 since text output doesn't include this data
     jq -n \
         --argjson loop_number "$loop_number" \
         --arg timestamp "$(get_iso_timestamp)" \
@@ -887,8 +1089,12 @@ 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" \
+        --argjson permission_denial_count "$permission_denial_count" \
+        --argjson denied_commands "$denied_commands_json" \
         '{
             loop_number: $loop_number,
             timestamp: $timestamp,
@@ -902,11 +1108,14 @@ 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: false,
-                permission_denial_count: 0,
-                denied_commands: []
+                has_permission_denials: $has_permission_denials,
+                permission_denial_count: $permission_denial_count,
+                denied_commands: $denied_commands
             }
         }' > "$analysis_result_file"
 
@@ -930,6 +1139,8 @@ update_exit_signals() {
     local has_completion_signal=$(jq -r -j '.analysis.has_completion_signal' "$analysis_file")
     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": []}')
@@ -944,8 +1155,9 @@ update_exit_signals() {
         fi
     fi
 
-    # Update done_signals array
-    if [[ "$has_completion_signal" == "true" ]]; then
+    # 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_progress_tracking_mismatch" != "true" && "$has_completion_signal" == "true" ]]; then
         signals=$(echo "$signals" | jq ".done_signals += [$loop_number]")
     fi
 
@@ -954,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 [[ "$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