bmalph 2.4.0 → 2.5.0

package/ralph/lib/circuit_breaker.sh

@@ -43,18 +43,19 @@ init_circuit_breaker() {
     fi
 
     if [[ ! -f "$CB_STATE_FILE" ]]; then
-        cat > "$CB_STATE_FILE" << EOF
-{
-    "state": "$CB_STATE_CLOSED",
-    "last_change": "$(get_iso_timestamp)",
-    "consecutive_no_progress": 0,
-    "consecutive_same_error": 0,
-    "consecutive_permission_denials": 0,
-    "last_progress_loop": 0,
-    "total_opens": 0,
-    "reason": ""
-}
-EOF
+        jq -n \
+            --arg state "$CB_STATE_CLOSED" \
+            --arg last_change "$(get_iso_timestamp)" \
+            '{
+                state: $state,
+                last_change: $last_change,
+                consecutive_no_progress: 0,
+                consecutive_same_error: 0,
+                consecutive_permission_denials: 0,
+                last_progress_loop: 0,
+                total_opens: 0,
+                reason: ""
+            }' > "$CB_STATE_FILE"
     fi
 
     # Ensure history file exists before any transition logging
@@ -81,18 +82,20 @@ EOF
             total_opens=$(jq -r '.total_opens // 0' "$CB_STATE_FILE" 2>/dev/null || echo "0")
             log_circuit_transition "$CB_STATE_OPEN" "$CB_STATE_CLOSED" "Auto-reset on startup (CB_AUTO_RESET=true)" "$current_loop"
 
-            cat > "$CB_STATE_FILE" << EOF
-{
-    "state": "$CB_STATE_CLOSED",
-    "last_change": "$(get_iso_timestamp)",
-    "consecutive_no_progress": 0,
-    "consecutive_same_error": 0,
-    "consecutive_permission_denials": 0,
-    "last_progress_loop": 0,
-    "total_opens": $total_opens,
-    "reason": "Auto-reset on startup"
-}
-EOF
+            jq -n \
+                --arg state "$CB_STATE_CLOSED" \
+                --arg last_change "$(get_iso_timestamp)" \
+                --argjson total_opens "$total_opens" \
+                '{
+                    state: $state,
+                    last_change: $last_change,
+                    consecutive_no_progress: 0,
+                    consecutive_same_error: 0,
+                    consecutive_permission_denials: 0,
+                    last_progress_loop: 0,
+                    total_opens: $total_opens,
+                    reason: "Auto-reset on startup"
+                }' > "$CB_STATE_FILE"
         else
             # Cooldown: check if enough time has elapsed to transition to HALF_OPEN
             local opened_at
@@ -296,20 +299,34 @@ record_loop_result() {
         opened_at=$(echo "$state_data" | jq -r '.opened_at // .last_change // ""' 2>/dev/null)
     fi
 
-    cat > "$CB_STATE_FILE" << EOF
-{
-    "state": "$new_state",
-    "last_change": "$(get_iso_timestamp)",
-    "consecutive_no_progress": $consecutive_no_progress,
-    "consecutive_same_error": $consecutive_same_error,
-    "consecutive_permission_denials": $consecutive_permission_denials,
-    "last_progress_loop": $last_progress_loop,
-    "total_opens": $total_opens,
-    "reason": "$reason",
-    "current_loop": $loop_number$(if [[ -n "$opened_at" ]]; then echo ",
-    \"opened_at\": \"$opened_at\""; fi)
-}
-EOF
+    jq -n \
+        --arg state "$new_state" \
+        --arg last_change "$(get_iso_timestamp)" \
+        --argjson consecutive_no_progress "$consecutive_no_progress" \
+        --argjson consecutive_same_error "$consecutive_same_error" \
+        --argjson consecutive_permission_denials "$consecutive_permission_denials" \
+        --argjson last_progress_loop "$last_progress_loop" \
+        --argjson total_opens "$total_opens" \
+        --arg reason "$reason" \
+        --argjson current_loop "$loop_number" \
+        '{
+            state: $state,
+            last_change: $last_change,
+            consecutive_no_progress: $consecutive_no_progress,
+            consecutive_same_error: $consecutive_same_error,
+            consecutive_permission_denials: $consecutive_permission_denials,
+            last_progress_loop: $last_progress_loop,
+            total_opens: $total_opens,
+            reason: $reason,
+            current_loop: $current_loop
+        }' > "$CB_STATE_FILE"
+
+    # Add opened_at if set (entering or staying in OPEN state)
+    if [[ -n "$opened_at" ]]; then
+        local tmp
+        tmp=$(jq --arg opened_at "$opened_at" '. + {opened_at: $opened_at}' "$CB_STATE_FILE")
+        echo "$tmp" > "$CB_STATE_FILE"
+    fi
 
     # Log state transition
     if [[ "$new_state" != "$current_state" ]]; then
@@ -331,15 +348,23 @@ log_circuit_transition() {
     local reason=$3
     local loop_number=$4
 
-    local history=$(cat "$CB_HISTORY_FILE")
-    local transition="{
-        \"timestamp\": \"$(get_iso_timestamp)\",
-        \"loop\": $loop_number,
-        \"from_state\": \"$from_state\",
-        \"to_state\": \"$to_state\",
-        \"reason\": \"$reason\"
-    }"
-
+    local transition
+    transition=$(jq -n -c \
+        --arg timestamp "$(get_iso_timestamp)" \
+        --argjson loop "$loop_number" \
+        --arg from_state "$from_state" \
+        --arg to_state "$to_state" \
+        --arg reason "$reason" \
+        '{
+            timestamp: $timestamp,
+            loop: $loop,
+            from_state: $from_state,
+            to_state: $to_state,
+            reason: $reason
+        }')
+
+    local history
+    history=$(cat "$CB_HISTORY_FILE")
     history=$(echo "$history" | jq ". += [$transition]")
     echo "$history" > "$CB_HISTORY_FILE"
 
@@ -406,18 +431,20 @@ show_circuit_status() {
 reset_circuit_breaker() {
     local reason=${1:-"Manual reset"}
 
-    cat > "$CB_STATE_FILE" << EOF
-{
-    "state": "$CB_STATE_CLOSED",
-    "last_change": "$(get_iso_timestamp)",
-    "consecutive_no_progress": 0,
-    "consecutive_same_error": 0,
-    "consecutive_permission_denials": 0,
-    "last_progress_loop": 0,
-    "total_opens": 0,
-    "reason": "$reason"
-}
-EOF
+    jq -n \
+        --arg state "$CB_STATE_CLOSED" \
+        --arg last_change "$(get_iso_timestamp)" \
+        --arg reason "$reason" \
+        '{
+            state: $state,
+            last_change: $last_change,
+            consecutive_no_progress: 0,
+            consecutive_same_error: 0,
+            consecutive_permission_denials: 0,
+            last_progress_loop: 0,
+            total_opens: 0,
+            reason: $reason
+        }' > "$CB_STATE_FILE"
 
     echo -e "${GREEN}✅ Circuit breaker reset to CLOSED state${NC}"
 }

package/ralph/lib/enable_core.sh

@@ -328,10 +328,9 @@ detect_project_context() {
             DETECTED_TEST_CMD="pnpm test"
             DETECTED_RUN_CMD="pnpm start"
         fi
-    fi
 
     # Detect from pyproject.toml or setup.py (Python)
-    if [[ -f "pyproject.toml" ]] || [[ -f "setup.py" ]]; then
+    elif [[ -f "pyproject.toml" ]] || [[ -f "setup.py" ]]; then
         DETECTED_PROJECT_TYPE="python"
 
         # Extract project name from pyproject.toml
@@ -358,19 +357,17 @@ detect_project_context() {
             DETECTED_TEST_CMD="pytest"
             DETECTED_RUN_CMD="python -m ${DETECTED_PROJECT_NAME:-main}"
         fi
-    fi
 
     # Detect from Cargo.toml (Rust)
-    if [[ -f "Cargo.toml" ]]; then
+    elif [[ -f "Cargo.toml" ]]; then
         DETECTED_PROJECT_TYPE="rust"
         DETECTED_PROJECT_NAME=$(grep -m1 '^name' Cargo.toml | sed 's/.*= *"\([^"]*\)".*/\1/' 2>/dev/null)
         DETECTED_BUILD_CMD="cargo build"
         DETECTED_TEST_CMD="cargo test"
         DETECTED_RUN_CMD="cargo run"
-    fi
 
     # Detect from go.mod (Go)
-    if [[ -f "go.mod" ]]; then
+    elif [[ -f "go.mod" ]]; then
         DETECTED_PROJECT_TYPE="go"
         DETECTED_PROJECT_NAME=$(head -1 go.mod | sed 's/module //' 2>/dev/null)
         DETECTED_BUILD_CMD="go build"

package/ralph/lib/response_analyzer.sh

@@ -829,37 +829,13 @@ should_resume_session() {
     fi
 
     # Calculate session age using date utilities
-    local now=$(get_epoch_seconds)
+    local now
+    now=$(get_epoch_seconds)
     local session_time
+    session_time=$(parse_iso_to_epoch "$timestamp")
 
-    # Parse ISO timestamp to epoch - try multiple formats for cross-platform compatibility
-    # Strip milliseconds if present (e.g., 2026-01-09T10:30:00.123+00:00 → 2026-01-09T10:30:00+00:00)
-    local clean_timestamp="${timestamp}"
-    if [[ "$timestamp" =~ \.[0-9]+[+-Z] ]]; then
-        clean_timestamp=$(echo "$timestamp" | sed 's/\.[0-9]*\([+-Z]\)/\1/')
-    fi
-
-    if command -v gdate &>/dev/null; then
-        # macOS with coreutils
-        session_time=$(gdate -d "$clean_timestamp" +%s 2>/dev/null)
-    elif date --version 2>&1 | grep -q GNU; then
-        # GNU date (Linux)
-        session_time=$(date -d "$clean_timestamp" +%s 2>/dev/null)
-    else
-        # BSD date (macOS without coreutils) - try parsing ISO format
-        # Format: 2026-01-09T10:30:00+00:00 or 2026-01-09T10:30:00Z
-        # Strip timezone suffix for BSD date parsing
-        local date_only="${clean_timestamp%[+-Z]*}"
-        session_time=$(date -j -f "%Y-%m-%dT%H:%M:%S" "$date_only" +%s 2>/dev/null)
-    fi
-
-    # If we couldn't parse the timestamp, consider session expired
-    if [[ -z "$session_time" || ! "$session_time" =~ ^[0-9]+$ ]]; then
-        echo "false"
-        return 1
-    fi
-
-    # Calculate age in seconds
+    # If parse_iso_to_epoch fell back to current epoch, session_time ≈ now → age ≈ 0.
+    # That's a safe default: treat unparseable timestamps as fresh rather than expired.
     local age=$((now - session_time))
 
     # Check if session is still valid (less than expiration time)

package/ralph/lib/task_sources.sh

@@ -308,21 +308,55 @@ extract_prd_tasks() {
         done <<< "$numbered_tasks"
     fi
 
-    # Look for headings that might be task sections
-    local headings
-    headings=$(grep -E '^#{1,3}[[:space:]]+(TODO|Tasks|Requirements|Features|Backlog|Sprint)' "$prd_file" 2>/dev/null)
-    if [[ -n "$headings" ]]; then
-        # Extract content after these headings as potential tasks
-        while IFS= read -r heading; do
-            local section_name
-            section_name=$(echo "$heading" | sed -E 's/^#*[[:space:]]*//')
-            # This is informational - actual task extraction would need more context
-        done <<< "$headings"
+    # Look for headings that might be task sections (with line numbers to handle duplicates)
+    local heading_lines
+    heading_lines=$(grep -nE '^#{1,3}[[:space:]]+(TODO|Tasks|Requirements|Features|Backlog|Sprint)' "$prd_file" 2>/dev/null)
+    if [[ -n "$heading_lines" ]]; then
+        # Extract bullet items beneath each matching heading
+        while IFS= read -r heading_entry; do
+            # Parse line number directly from grep -n output (avoids duplicate heading issue)
+            local heading_line
+            heading_line=$(echo "$heading_entry" | cut -d: -f1)
+            [[ -z "$heading_line" ]] && continue
+
+            # Find the next heading (any level) after this one
+            local next_heading_line
+            next_heading_line=$(tail -n +"$((heading_line + 1))" "$prd_file" | grep -n '^#' | head -1 | cut -d: -f1)
+
+            # Extract the section content
+            local section_content
+            if [[ -n "$next_heading_line" ]]; then
+                local end_line=$((heading_line + next_heading_line - 1))
+                section_content=$(sed -n "$((heading_line + 1)),${end_line}p" "$prd_file")
+            else
+                section_content=$(tail -n +"$((heading_line + 1))" "$prd_file")
+            fi
+
+            # Extract bullet items from section and convert to checkboxes
+            while IFS= read -r line; do
+                local task_text=""
+                # Match "- item" or "* item" (but not checkboxes, already handled above)
+                if [[ "$line" =~ ^[[:space:]]*[-*][[:space:]]+(.+)$ ]]; then
+                    task_text="${BASH_REMATCH[1]}"
+                    # Skip checkbox lines — they are handled by the earlier extraction
+                    if [[ "$line" == *"["*"]"* ]]; then
+                        task_text=""
+                    fi
+                # Match "N. item" numbered patterns
+                elif [[ "$line" =~ ^[[:space:]]*[0-9]+\.[[:space:]]+(.+)$ ]]; then
+                    task_text="${BASH_REMATCH[1]}"
+                fi
+                if [[ -n "$task_text" ]]; then
+                    tasks="${tasks}
+- [ ] ${task_text}"
+                fi
+            done <<< "$section_content"
+        done <<< "$heading_lines"
     fi
 
     # Clean up and output
     if [[ -n "$tasks" ]]; then
-        echo "$tasks" | grep -v '^$' | head -30  # Limit to 30 tasks
+        echo "$tasks" | grep -v '^$' | awk '!seen[$0]++' | head -30  # Deduplicate, limit to 30
         return 0
     fi
 

package/ralph/lib/wizard_utils.sh

@@ -475,6 +475,15 @@ show_progress() {
     local total=$2
     local message=$3
 
+    # Guard against division by zero
+    if [[ $total -le 0 ]]; then
+        local bar_width=30
+        local bar=""
+        for ((i = 0; i < bar_width; i++)); do bar+="░"; done
+        echo -en "\r${WIZARD_CYAN}[${bar}]${WIZARD_NC} 0/${total} ${message}"
+        return 0
+    fi
+
     local bar_width=30
     local filled=$((current * bar_width / total))
     local empty=$((bar_width - filled))

package/ralph/ralph_import.sh

@@ -2,6 +2,10 @@
 
 # Ralph Import - Convert PRDs to Ralph format using Claude Code
 # Version: 0.9.8 - Modern CLI support with JSON output parsing
+#
+# DEPRECATED: This script is from standalone Ralph and references `ralph-setup`
+# which does not exist in bmalph. Use `bmalph implement` for PRD-to-Ralph
+# transition instead. This file is bundled for backward compatibility only.
 set -e
 
 # Configuration
@@ -281,8 +285,9 @@ HELPEOF
 # Check dependencies
 check_dependencies() {
     if ! command -v ralph-setup &> /dev/null; then
-        log "ERROR" "Ralph not installed. Run ./install.sh first"
-        exit 1
+        log "WARN" "ralph-setup not found. If using bmalph, run 'bmalph init' instead."
+        log "WARN" "This script is deprecated — use 'bmalph implement' for PRD conversion."
+        return 1
     fi
 
     if ! command -v jq &> /dev/null; then

package/ralph/ralph_loop.sh

@@ -19,7 +19,7 @@ source "$SCRIPT_DIR/lib/circuit_breaker.sh"
 
 # Configuration
 # Ralph-specific files live in .ralph/ subfolder
-RALPH_DIR=".ralph"
+RALPH_DIR="${RALPH_DIR:-.ralph}"
 PROMPT_FILE="$RALPH_DIR/PROMPT.md"
 LOG_DIR="$RALPH_DIR/logs"
 DOCS_DIR="$RALPH_DIR/docs/generated"
@@ -239,7 +239,10 @@ setup_tmux_session() {
     tmux send-keys -t "$session_name:${base_win}.1" "tail -f '$project_dir/$LIVE_LOG_FILE'" Enter
 
     # Right-bottom pane (pane 2): Ralph status monitor
-    if command -v ralph-monitor &> /dev/null; then
+    # Prefer bmalph watch (TypeScript, fully tested) over legacy ralph_monitor.sh
+    if command -v bmalph &> /dev/null; then
+        tmux send-keys -t "$session_name:${base_win}.2" "bmalph watch" Enter
+    elif command -v ralph-monitor &> /dev/null; then
         tmux send-keys -t "$session_name:${base_win}.2" "ralph-monitor" Enter
     else
         tmux send-keys -t "$session_name:${base_win}.2" "'$ralph_home/ralph_monitor.sh'" Enter
@@ -404,18 +407,6 @@ can_make_call() {
     fi
 }
 
-# Increment call counter
-increment_call_counter() {
-    local calls_made=0
-    if [[ -f "$CALL_COUNT_FILE" ]]; then
-        calls_made=$(cat "$CALL_COUNT_FILE")
-    fi
-    
-    ((calls_made++))
-    echo "$calls_made" > "$CALL_COUNT_FILE"
-    echo "$calls_made"
-}
-
 # Wait for rate limit reset with countdown
 wait_for_reset() {
     local calls_made=$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")
@@ -661,10 +652,9 @@ build_loop_context() {
     echo "${context:0:500}"
 }
 
-# Get session file age in hours (cross-platform)
-# Returns: age in hours on stdout, or -1 if stat fails
-# Note: Returns 0 for files less than 1 hour old
-get_session_file_age_hours() {
+# Get session file age in seconds (cross-platform)
+# Returns: age in seconds on stdout, or -1 if stat fails
+get_session_file_age_seconds() {
     local file=$1
 
     if [[ ! -f "$file" ]]; then
@@ -700,9 +690,8 @@ get_session_file_age_hours() {
     current_time=$(date +%s)
 
     local age_seconds=$((current_time - file_mtime))
-    local age_hours=$((age_seconds / 3600))
 
-    echo "$age_hours"
+    echo "$age_seconds"
 }
 
 # Initialize or resume Claude session (with expiration check)
@@ -723,20 +712,23 @@ get_session_file_age_hours() {
 init_claude_session() {
     if [[ -f "$CLAUDE_SESSION_FILE" ]]; then
         # Check session age
-        local age_hours
-        age_hours=$(get_session_file_age_hours "$CLAUDE_SESSION_FILE")
+        local age_seconds
+        age_seconds=$(get_session_file_age_seconds "$CLAUDE_SESSION_FILE")
 
         # Handle stat failure (-1) - treat as needing new session
         # Don't expire sessions when we can't determine age
-        if [[ $age_hours -eq -1 ]]; then
+        if [[ $age_seconds -eq -1 ]]; then
             log_status "WARN" "Could not determine session age, starting new session"
             rm -f "$CLAUDE_SESSION_FILE"
             echo ""
             return 0
         fi
 
+        local expiry_seconds=$((CLAUDE_SESSION_EXPIRY_HOURS * 3600))
+
         # Check if session has expired
-        if [[ $age_hours -ge $CLAUDE_SESSION_EXPIRY_HOURS ]]; then
+        if [[ $age_seconds -ge $expiry_seconds ]]; then
+            local age_hours=$((age_seconds / 3600))
             log_status "INFO" "Session expired (${age_hours}h old, max ${CLAUDE_SESSION_EXPIRY_HOURS}h), starting new session"
             rm -f "$CLAUDE_SESSION_FILE"
             echo ""
@@ -746,6 +738,7 @@ init_claude_session() {
         # Session is valid, try to read it
         local session_id=$(cat "$CLAUDE_SESSION_FILE" 2>/dev/null)
         if [[ -n "$session_id" ]]; then
+            local age_hours=$((age_seconds / 3600))
             log_status "INFO" "Resuming Claude session: ${session_id:0:20}... (${age_hours}h old)"
             echo "$session_id"
             return 0
@@ -1661,6 +1654,9 @@ Examples:
 HELPEOF
 }
 
+# Only parse arguments and run main when executed directly, not when sourced
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+
 # Parse command line arguments
 while [[ $# -gt 0 ]]; do
     case $1 in
@@ -1768,14 +1764,13 @@ while [[ $# -gt 0 ]]; do
     esac
 done
 
-# Only execute when run directly, not when sourced
-if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
-    # If tmux mode requested, set it up
-    if [[ "$USE_TMUX" == "true" ]]; then
-        check_tmux_available
-        setup_tmux_session
-    fi
-
-    # Start the main loop
-    main
+# If tmux mode requested, set it up
+if [[ "$USE_TMUX" == "true" ]]; then
+    check_tmux_available
+    setup_tmux_session
 fi
+
+# Start the main loop
+main
+
+fi  # end: BASH_SOURCE[0] == $0

package/ralph/ralph_monitor.sh

@@ -1,6 +1,10 @@
 #!/bin/bash
 
 # Ralph Status Monitor - Live terminal dashboard for the Ralph loop
+#
+# DEPRECATED: Use `bmalph watch` instead, which provides a more capable
+# TypeScript-based live dashboard with full test coverage.
+# This script is kept for backward compatibility in tmux sessions.
 set -e
 
 STATUS_FILE=".ralph/status.json"

package/slash-commands/bmalph-watch.md

@@ -0,0 +1,20 @@
+# Ralph Live Dashboard
+
+Launch the bmalph live dashboard to monitor Ralph loop progress in real-time.
+
+## How to Run
+
+Execute the CLI command:
+    bmalph watch
+
+## What It Does
+
+- Displays a live-updating terminal dashboard for Ralph loop monitoring
+- Shows loop count, circuit breaker state, story progress, and session info
+- Displays recent log entries and response analysis
+- Auto-refreshes every 2 seconds
+- Press `q` or `Ctrl+C` to exit
+
+## When to Use
+
+Use this command while the Ralph loop is running to monitor progress without switching windows. It replaces the legacy `ralph_monitor.sh` script with a more capable TypeScript-based dashboard.