bmalph 2.7.6 → 2.8.0

package/ralph/lib/response_analyzer.sh

@@ -97,7 +97,8 @@ contains_permission_denial_signal() {
     local line
     while IFS= read -r line; do
         local trimmed="${line#"${line%%[![:space:]]*}"}"
-        local normalized="${trimmed,,}"
+        local normalized
+        normalized="$(printf '%s' "$trimmed" | tr '[:upper:]' '[:lower:]')"
 
         if permission_denial_line_matches "$normalized"; then
             return 0
@@ -225,6 +226,35 @@ normalize_cursor_stream_json_response() {
     ' "$output_file" > "$normalized_file"
 }
 
+# Normalize OpenCode JSON event output into the object shape expected downstream.
+normalize_opencode_jsonl_response() {
+    local output_file=$1
+    local normalized_file=$2
+
+    jq -rs '
+        def assistant_text($message):
+            [($message.parts // [])[]? | select(.type == "text") | .text]
+            | join("\n");
+
+        (map(
+            select(
+                (.type == "message.updated" or .type == "message.completed")
+                and (.message.role // "") == "assistant"
+            )
+        ) | last | .message // {}) as $assistant_message
+        | {
+            result: assistant_text($assistant_message),
+            sessionId: (
+                map(.session.id // .session_id // .sessionId // empty)
+                | map(select(length > 0))
+                | first
+                // ""
+            ),
+            metadata: {}
+        }
+    ' "$output_file" > "$normalized_file"
+}
+
 # Detect whether a multi-document stream matches Codex JSONL events.
 is_codex_jsonl_output() {
     local output_file=$1
@@ -240,6 +270,25 @@ is_codex_jsonl_output() {
     ' < "$output_file" 2>/dev/null
 }
 
+# Detect whether a multi-document stream matches OpenCode JSON events.
+is_opencode_jsonl_output() {
+    local output_file=$1
+
+    jq -n -j '
+        reduce inputs as $item (
+            false;
+            . or (
+                $item.type == "session.created" or
+                $item.type == "session.updated" or
+                (
+                    ($item.type == "message.updated" or $item.type == "message.completed")
+                    and ($item.message.role? != null)
+                )
+            )
+        )
+    ' < "$output_file" 2>/dev/null
+}
+
 # Detect whether a multi-document stream matches Cursor stream-json events.
 is_cursor_stream_json_output() {
     local output_file=$1
@@ -275,6 +324,14 @@ normalize_json_output() {
             return $?
         fi
 
+        local is_opencode_jsonl
+        is_opencode_jsonl=$(is_opencode_jsonl_output "$output_file") || return 1
+
+        if [[ "$is_opencode_jsonl" == "true" ]]; then
+            normalize_opencode_jsonl_response "$output_file" "$normalized_file"
+            return $?
+        fi
+
         local is_cursor_stream_json
         is_cursor_stream_json=$(is_cursor_stream_json_output "$output_file") || return 1
 
@@ -372,6 +429,17 @@ detect_output_format() {
             return
         fi
 
+        local is_opencode_jsonl
+        is_opencode_jsonl=$(is_opencode_jsonl_output "$output_file") || {
+            echo "text"
+            return
+        }
+
+        if [[ "$is_opencode_jsonl" == "true" ]]; then
+            echo "json"
+            return
+        fi
+
         local is_cursor_stream_json
         is_cursor_stream_json=$(is_cursor_stream_json_output "$output_file") || {
             echo "text"
@@ -396,14 +464,84 @@ 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 tests_status="UNKNOWN"
+    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
+                ;;
+            TESTS_STATUS:*)
+                value=$(trim_shell_whitespace "${trimmed#TESTS_STATUS:}")
+                [[ -n "$value" ]] && tests_status="$value"
+                ;;
+        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" \
+        --arg tests_status "$tests_status" \
+        '{
+            status: $status,
+            exit_signal_found: $exit_signal_found,
+            exit_signal: $exit_signal,
+            tasks_completed_this_loop: $tasks_completed_this_loop,
+            tests_status: $tests_status
+        }'
+}
+
 # Parse JSON response and extract structured fields
 # Creates .ralph/.json_parse_result with normalized analysis data
-# Supports FIVE JSON formats:
+# Supports SIX JSON formats:
 # 1. Flat format: { status, exit_signal, work_type, files_modified, ... }
 # 2. Claude CLI object format: { result, sessionId, metadata: { files_changed, has_errors, completion_status, ... } }
 # 3. Claude CLI array format: [ {type: "system", ...}, {type: "assistant", ...}, {type: "result", ...} ]
 # 4. Codex JSONL format: {"type":"thread.started",...}\n{"type":"item.completed","item":{...}}
-# 5. Cursor stream-json format: {"type":"assistant",...}\n{"type":"result",...}
+# 5. OpenCode JSON event format: {"type":"session.created",...}\n{"type":"message.updated",...}
+# 6. Cursor stream-json format: {"type":"assistant",...}\n{"type":"result",...}
 parse_json_response() {
     local output_file=$1
     local result_file="${2:-$RALPH_DIR/.json_parse_result}"
@@ -441,112 +579,173 @@ parse_json_response() {
         output_file="$normalized_file"
 
         if [[ "$response_shape" == "jsonl" ]]; then
-            if is_codex_jsonl_output "$original_output_file" >/dev/null 2>&1; then
+            if [[ "$(is_codex_jsonl_output "$original_output_file")" == "true" ]]; then
                 response_shape="codex_jsonl"
+            elif [[ "$(is_opencode_jsonl_output "$original_output_file")" == "true" ]]; then
+                response_shape="opencode_jsonl"
             else
                 response_shape="cursor_stream_jsonl"
             fi
         fi
     fi
 
-    # Detect JSON format by checking for Claude CLI fields
-    local has_result_field=$(jq -r -j 'has("result")' "$output_file" 2>/dev/null)
+    local has_result_field="false"
+    local status="UNKNOWN"
+    local completion_status=""
+    local exit_signal="false"
+    local explicit_exit_signal_found="false"
+    local tasks_completed_this_loop=0
+    local tests_status="UNKNOWN"
+    local result_text=""
+    local work_type="UNKNOWN"
+    local files_modified=0
+    local error_count=0
+    local has_errors="false"
+    local summary=""
+    local session_id=""
+    local loop_number=0
+    local confidence=0
+    local progress_count=0
+    local permission_denial_count=0
+    local has_permission_denials="false"
+    local denied_commands_json="[]"
 
-    # Extract fields - support both flat format and Claude CLI format
-    # Priority: Claude CLI fields first, then flat format fields
+    if [[ "$response_shape" == "codex_jsonl" || "$response_shape" == "opencode_jsonl" || "$response_shape" == "cursor_stream_jsonl" ]]; then
+        local driver_fields=""
+        driver_fields=$(jq -r '
+            [
+                (.result // ""),
+                (.sessionId // .metadata.session_id // .session_id // ""),
+                ((.permission_denials // []) | length),
+                ((.permission_denials // []) | map(
+                    if .tool_name == "Bash" then
+                        "Bash(\(.tool_input.command // "?" | split("\n")[0] | .[0:60]))"
+                    else
+                        .tool_name // "unknown"
+                    end
+                ) | @json)
+            ] | @tsv
+        ' "$output_file" 2>/dev/null)
+
+        local denied_commands_field="[]"
+        IFS=$'\t' read -r result_text session_id permission_denial_count denied_commands_field <<< "$driver_fields"
+
+        has_result_field="true"
+        summary="$result_text"
+        denied_commands_json="${denied_commands_field:-[]}"
+
+        if [[ ! "$permission_denial_count" =~ ^-?[0-9]+$ ]]; then
+            permission_denial_count=0
+        fi
 
-    # Status: from flat format OR derived from metadata.completion_status
-    local status=$(jq -r -j '.status // "UNKNOWN"' "$output_file" 2>/dev/null)
-    local completion_status=$(jq -r -j '.metadata.completion_status // ""' "$output_file" 2>/dev/null)
-    if [[ "$completion_status" == "complete" || "$completion_status" == "COMPLETE" ]]; then
-        status="COMPLETE"
-    fi
+        if [[ $permission_denial_count -gt 0 ]]; then
+            has_permission_denials="true"
+        fi
+    else
+        # Detect JSON format by checking for Claude CLI fields
+        has_result_field=$(jq -r -j 'has("result")' "$output_file" 2>/dev/null)
 
-    # Exit signal: from flat format OR derived from completion_status
-    # 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)
-
-    # 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
+        # Extract fields - support both flat format and Claude CLI format
+        # Priority: Claude CLI fields first, then flat format fields
+
+        # Status: from flat format OR derived from metadata.completion_status
+        status=$(jq -r -j '.status // "UNKNOWN"' "$output_file" 2>/dev/null)
+        completion_status=$(jq -r -j '.metadata.completion_status // ""' "$output_file" 2>/dev/null)
+        if [[ "$completion_status" == "complete" || "$completion_status" == "COMPLETE" ]]; then
+            status="COMPLETE"
         fi
-    fi
 
-    # Work type: from flat format
-    local work_type=$(jq -r -j '.work_type // "UNKNOWN"' "$output_file" 2>/dev/null)
-
-    # Files modified: from flat format OR from metadata.files_changed
-    local files_modified=$(jq -r -j '.metadata.files_changed // .files_modified // 0' "$output_file" 2>/dev/null)
-
-    # Error count: from flat format OR derived from metadata.has_errors
-    # Note: When only has_errors=true is present (without explicit error_count),
-    # we set error_count=1 as a minimum. This is defensive programming since
-    # the stuck detection threshold is >5 errors, so 1 error won't trigger it.
-    # Actual error count may be higher, but precise count isn't critical for our logic.
-    local error_count=$(jq -r -j '.error_count // 0' "$output_file" 2>/dev/null)
-    local has_errors=$(jq -r -j '.metadata.has_errors // false' "$output_file" 2>/dev/null)
-    if [[ "$has_errors" == "true" && "$error_count" == "0" ]]; then
-        error_count=1  # At least one error if has_errors is true
-    fi
+        # Exit signal: from flat format OR derived from completion_status
+        # Track whether EXIT_SIGNAL was explicitly provided (vs inferred from STATUS)
+        exit_signal=$(jq -r -j '.exit_signal // false' "$output_file" 2>/dev/null)
+        explicit_exit_signal_found=$(jq -r -j 'has("exit_signal")' "$output_file" 2>/dev/null)
+        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
 
-    # Summary: from flat format OR from result field (Claude CLI format)
-    local summary=$(jq -r -j '.result // .summary // ""' "$output_file" 2>/dev/null)
+        if [[ "$has_result_field" == "true" ]]; then
+            result_text=$(jq -r -j '.result // ""' "$output_file" 2>/dev/null)
+        fi
 
-    # Session ID: from Claude CLI format (sessionId) OR from metadata.session_id
-    local session_id=$(jq -r -j '.sessionId // .metadata.session_id // .session_id // ""' "$output_file" 2>/dev/null)
+        # Work type: from flat format
+        work_type=$(jq -r -j '.work_type // "UNKNOWN"' "$output_file" 2>/dev/null)
+
+        # Files modified: from flat format OR from metadata.files_changed
+        files_modified=$(jq -r -j '.metadata.files_changed // .files_modified // 0' "$output_file" 2>/dev/null)
+
+        # Error count: from flat format OR derived from metadata.has_errors
+        # Note: When only has_errors=true is present (without explicit error_count),
+        # we set error_count=1 as a minimum. This is defensive programming since
+        # the stuck detection threshold is >5 errors, so 1 error won't trigger it.
+        # Actual error count may be higher, but precise count isn't critical for our logic.
+        error_count=$(jq -r -j '.error_count // 0' "$output_file" 2>/dev/null)
+        has_errors=$(jq -r -j '.metadata.has_errors // false' "$output_file" 2>/dev/null)
+        if [[ "$has_errors" == "true" && "$error_count" == "0" ]]; then
+            error_count=1  # At least one error if has_errors is true
+        fi
 
-    # Loop number: from metadata
-    local loop_number=$(jq -r -j '.metadata.loop_number // .loop_number // 0' "$output_file" 2>/dev/null)
+        # Summary: from flat format OR from result field (Claude CLI format)
+        summary=$(jq -r -j '.result // .summary // ""' "$output_file" 2>/dev/null)
 
-    # Confidence: from flat format
-    local confidence=$(jq -r -j '.confidence // 0' "$output_file" 2>/dev/null)
+        # Session ID: from Claude CLI format (sessionId) OR from metadata.session_id
+        session_id=$(jq -r -j '.sessionId // .metadata.session_id // .session_id // ""' "$output_file" 2>/dev/null)
 
-    # Progress indicators: from Claude CLI metadata (optional)
-    local progress_count=$(jq -r -j '.metadata.progress_indicators | if . then length else 0 end' "$output_file" 2>/dev/null)
+        # Loop number: from metadata
+        loop_number=$(jq -r -j '.metadata.loop_number // .loop_number // 0' "$output_file" 2>/dev/null)
 
-    # Permission denials: from Claude Code output (Issue #101)
-    # When Claude Code is denied permission to run commands, it outputs a permission_denials array
-    local permission_denial_count=$(jq -r -j '.permission_denials | if . then length else 0 end' "$output_file" 2>/dev/null)
-    permission_denial_count=$((permission_denial_count + 0))  # Ensure integer
+        # Confidence: from flat format
+        confidence=$(jq -r -j '.confidence // 0' "$output_file" 2>/dev/null)
 
-    local has_permission_denials="false"
-    if [[ $permission_denial_count -gt 0 ]]; then
-        has_permission_denials="true"
+        # Progress indicators: from Claude CLI metadata (optional)
+        progress_count=$(jq -r -j '.metadata.progress_indicators | if . then length else 0 end' "$output_file" 2>/dev/null)
+
+        # Permission denials: from Claude Code output (Issue #101)
+        # When Claude Code is denied permission to run commands, it outputs a permission_denials array
+        permission_denial_count=$(jq -r -j '.permission_denials | if . then length else 0 end' "$output_file" 2>/dev/null)
+        permission_denial_count=$((permission_denial_count + 0))  # Ensure integer
+
+        if [[ $permission_denial_count -gt 0 ]]; then
+            has_permission_denials="true"
+        fi
+
+        # Extract denied tool names and commands for logging/display
+        # Shows tool_name for non-Bash tools, and for Bash tools shows the command that was denied
+        # This handles both cases: AskUserQuestion denial shows "AskUserQuestion",
+        # while Bash denial shows "Bash(git commit -m ...)" with truncated command
+        if [[ $permission_denial_count -gt 0 ]]; then
+            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
     fi
 
-    # Extract denied tool names and commands for logging/display
-    # Shows tool_name for non-Bash tools, and for Bash tools shows the command that was denied
-    # This handles both cases: AskUserQuestion denial shows "AskUserQuestion",
-    # while Bash denial shows "Bash(git commit -m ...)" with truncated command
-    local denied_commands_json="[]"
-    if [[ $permission_denial_count -gt 0 ]]; then
-        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 "[]")
+    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)
+        local embedded_tests_status
+        embedded_tests_status=$(printf '%s' "$ralph_status_json" | jq -r -j '.tests_status' 2>/dev/null)
+
+        if [[ "$embedded_tasks_completed" =~ ^-?[0-9]+$ ]]; then
+            tasks_completed_this_loop=$embedded_tasks_completed
+        fi
+        if [[ -n "$embedded_tests_status" && "$embedded_tests_status" != "null" ]]; then
+            tests_status="$embedded_tests_status"
+        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
 
     # Heuristic permission-denial matching is limited to the refusal-shaped
@@ -561,7 +760,7 @@ parse_json_response() {
     # completion markers are absent. This keeps JSONL analysis aligned with text mode.
     local summary_has_completion_keyword="false"
     local summary_has_no_work_pattern="false"
-    if [[ "$response_shape" == "codex_jsonl" || "$response_shape" == "cursor_stream_jsonl" ]] && [[ "$explicit_exit_signal_found" != "true" && -n "$summary" ]]; then
+    if [[ "$response_shape" == "codex_jsonl" || "$response_shape" == "opencode_jsonl" || "$response_shape" == "cursor_stream_jsonl" ]] && [[ "$explicit_exit_signal_found" != "true" && -n "$summary" ]]; then
         for keyword in "${COMPLETION_KEYWORDS[@]}"; do
             if echo "$summary" | grep -qi "$keyword"; then
                 summary_has_completion_keyword="true"
@@ -640,9 +839,11 @@ 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" \
+        --arg tests_status "$tests_status" \
         '{
             status: $status,
             exit_signal: $exit_signal,
@@ -655,6 +856,8 @@ parse_json_response() {
             loop_number: $loop_number,
             session_id: $session_id,
             confidence: $confidence,
+            tasks_completed_this_loop: $tasks_completed_this_loop,
+            tests_status: $tests_status,
             has_permission_denials: $has_permission_denials,
             permission_denial_count: $permission_denial_count,
             denied_commands: $denied_commands,
@@ -687,6 +890,8 @@ analyze_response() {
     local exit_signal=false
     local work_summary=""
     local files_modified=0
+    local tasks_completed_this_loop=0
+    local tests_status="UNKNOWN"
 
     # Read output file
     if [[ ! -f "$output_file" ]]; then
@@ -712,6 +917,8 @@ 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")
+            tests_status=$(jq -r -j '.tests_status // "UNKNOWN"' "$json_parse_result_file" 2>/dev/null || echo "UNKNOWN")
             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 +940,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,11 +995,13 @@ 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" \
+                --arg tests_status "$tests_status" \
                 '{
                     loop_number: $loop_number,
                     timestamp: $timestamp,
@@ -802,6 +1015,10 @@ analyze_response() {
                         files_modified: $files_modified,
                         confidence_score: $confidence_score,
                         exit_signal: $exit_signal,
+                        tasks_completed_this_loop: $tasks_completed_this_loop,
+                        tests_status: $tests_status,
+                        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 +1040,28 @@ 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)
+        local parsed_tests_status
+        parsed_tests_status=$(printf '%s' "$ralph_status_json" | jq -r -j '.tests_status' 2>/dev/null)
+
+        if [[ "$parsed_tasks_completed" =~ ^-?[0-9]+$ ]]; then
+            tasks_completed_this_loop=$parsed_tasks_completed
+        fi
+        if [[ -n "$parsed_tests_status" && "$parsed_tests_status" != "null" ]]; then
+            tests_status="$parsed_tests_status"
+        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,11 +1234,13 @@ 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" \
+        --arg tests_status "$tests_status" \
         '{
             loop_number: $loop_number,
             timestamp: $timestamp,
@@ -1020,6 +1254,10 @@ analyze_response() {
                 files_modified: $files_modified,
                 confidence_score: $confidence_score,
                 exit_signal: $exit_signal,
+                tasks_completed_this_loop: $tasks_completed_this_loop,
+                tests_status: $tests_status,
+                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 +1287,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 +1304,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 +1313,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
 
@@ -1294,8 +1533,10 @@ export -f detect_output_format
 export -f count_json_documents
 export -f normalize_cli_array_response
 export -f normalize_codex_jsonl_response
+export -f normalize_opencode_jsonl_response
 export -f normalize_cursor_stream_json_response
 export -f is_codex_jsonl_output
+export -f is_opencode_jsonl_output
 export -f is_cursor_stream_json_output
 export -f normalize_json_output
 export -f extract_session_id_from_output

package/ralph/lib/wizard_utils.sh

@@ -36,7 +36,7 @@ confirm() {
     local response
 
     local yn_hint="[y/N]"
-    if [[ "${default,,}" == "y" ]]; then
+    if [[ "$default" == [yY] ]]; then
         yn_hint="[Y/n]"
     fi
 
@@ -50,11 +50,11 @@ confirm() {
             response="$default"
         fi
 
-        case "${response,,}" in
-            y|yes)
+        case "$response" in
+            [yY]|[yY][eE][sS])
                 return 0
                 ;;
-            n|no)
+            [nN]|[nN][oO])
                 return 1
                 ;;
             *)