@@ -22,6 +22,7 @@ CB_NO_PROGRESS_THRESHOLD=${CB_NO_PROGRESS_THRESHOLD:-3}        # Open circuit af
 CB_SAME_ERROR_THRESHOLD=${CB_SAME_ERROR_THRESHOLD:-5}          # Open circuit after N loops with same error
 CB_OUTPUT_DECLINE_THRESHOLD=${CB_OUTPUT_DECLINE_THRESHOLD:-70} # Open circuit if output declines by >70%
 CB_PERMISSION_DENIAL_THRESHOLD=${CB_PERMISSION_DENIAL_THRESHOLD:-2}  # Open circuit after N loops with permission denials (Issue #101)
+CB_READ_ONLY_TIMEOUT_THRESHOLD=${CB_READ_ONLY_TIMEOUT_THRESHOLD:-2}  # Open circuit after N consecutive read-only timeouts (#146)
 CB_COOLDOWN_MINUTES=${CB_COOLDOWN_MINUTES:-30}                      # Minutes before OPEN → HALF_OPEN auto-recovery (Issue #160)
 CB_AUTO_RESET=${CB_AUTO_RESET:-false}                               # Reset to CLOSED on startup instead of waiting for cooldown
 
@@ -52,6 +53,7 @@ init_circuit_breaker() {
                 consecutive_no_progress: 0,
                 consecutive_same_error: 0,
                 consecutive_permission_denials: 0,
+                consecutive_read_only_timeouts: 0,
                 last_progress_loop: 0,
                 total_opens: 0,
                 reason: ""
@@ -92,6 +94,7 @@ init_circuit_breaker() {
                     consecutive_no_progress: 0,
                     consecutive_same_error: 0,
                     consecutive_permission_denials: 0,
+                    consecutive_read_only_timeouts: 0,
                     last_progress_loop: 0,
                     total_opens: $total_opens,
                     reason: "Auto-reset on startup"
@@ -155,6 +158,7 @@ record_loop_result() {
     local files_changed=$2
     local has_errors=$3
     local output_length=$4
+    local was_read_only_timeout=${5:-false}
 
     init_circuit_breaker
 
@@ -163,14 +167,23 @@ record_loop_result() {
     local consecutive_no_progress=$(echo "$state_data" | jq -r '.consecutive_no_progress' | tr -d '[:space:]')
     local consecutive_same_error=$(echo "$state_data" | jq -r '.consecutive_same_error' | tr -d '[:space:]')
     local consecutive_permission_denials=$(echo "$state_data" | jq -r '.consecutive_permission_denials // 0' | tr -d '[:space:]')
+    local consecutive_read_only_timeouts=$(echo "$state_data" | jq -r '.consecutive_read_only_timeouts // 0' | tr -d '[:space:]')
     local last_progress_loop=$(echo "$state_data" | jq -r '.last_progress_loop' | tr -d '[:space:]')
 
     # Ensure integers
     consecutive_no_progress=$((consecutive_no_progress + 0))
     consecutive_same_error=$((consecutive_same_error + 0))
     consecutive_permission_denials=$((consecutive_permission_denials + 0))
+    consecutive_read_only_timeouts=$((consecutive_read_only_timeouts + 0))
     last_progress_loop=$((last_progress_loop + 0))
 
+    # Track read-only timeouts (#146)
+    if [[ "$was_read_only_timeout" == "true" ]]; then
+        consecutive_read_only_timeouts=$((consecutive_read_only_timeouts + 1))
+    else
+        consecutive_read_only_timeouts=0
+    fi
+
     # Detect progress from multiple sources:
     # 1. Files changed (git diff)
     # 2. Completion signal in response analysis (STATUS: COMPLETE or has_completion_signal)
@@ -249,6 +262,9 @@ record_loop_result() {
             if [[ $consecutive_permission_denials -ge $CB_PERMISSION_DENIAL_THRESHOLD ]]; then
                 new_state="$CB_STATE_OPEN"
                 reason="Permission denied in $consecutive_permission_denials consecutive loops"
+            elif [[ $consecutive_read_only_timeouts -ge $CB_READ_ONLY_TIMEOUT_THRESHOLD ]]; then
+                new_state="$CB_STATE_OPEN"
+                reason="Read-only timeout in $consecutive_read_only_timeouts consecutive loops (agent stuck reading)"
             elif [[ $consecutive_no_progress -ge $CB_NO_PROGRESS_THRESHOLD ]]; then
                 new_state="$CB_STATE_OPEN"
                 reason="No progress detected in $consecutive_no_progress consecutive loops"
@@ -267,6 +283,9 @@ record_loop_result() {
             if [[ $consecutive_permission_denials -ge $CB_PERMISSION_DENIAL_THRESHOLD ]]; then
                 new_state="$CB_STATE_OPEN"
                 reason="Permission denied in $consecutive_permission_denials consecutive loops"
+            elif [[ $consecutive_read_only_timeouts -ge $CB_READ_ONLY_TIMEOUT_THRESHOLD ]]; then
+                new_state="$CB_STATE_OPEN"
+                reason="Read-only timeout in $consecutive_read_only_timeouts consecutive loops (agent stuck reading)"
             elif [[ "$has_progress" == "true" ]]; then
                 new_state="$CB_STATE_CLOSED"
                 reason="Progress detected, circuit recovered"
@@ -305,6 +324,7 @@ record_loop_result() {
         --argjson consecutive_no_progress "$consecutive_no_progress" \
         --argjson consecutive_same_error "$consecutive_same_error" \
         --argjson consecutive_permission_denials "$consecutive_permission_denials" \
+        --argjson consecutive_read_only_timeouts "$consecutive_read_only_timeouts" \
         --argjson last_progress_loop "$last_progress_loop" \
         --argjson total_opens "$total_opens" \
         --arg reason "$reason" \
@@ -315,6 +335,7 @@ record_loop_result() {
             consecutive_no_progress: $consecutive_no_progress,
             consecutive_same_error: $consecutive_same_error,
             consecutive_permission_denials: $consecutive_permission_denials,
+            consecutive_read_only_timeouts: $consecutive_read_only_timeouts,
             last_progress_loop: $last_progress_loop,
             total_opens: $total_opens,
             reason: $reason,
@@ -441,6 +462,7 @@ reset_circuit_breaker() {
             consecutive_no_progress: 0,
             consecutive_same_error: 0,
             consecutive_permission_denials: 0,
+            consecutive_read_only_timeouts: 0,
             last_progress_loop: 0,
             total_opens: 0,
             reason: $reason
 
@@ -688,6 +688,7 @@ PROJECT_TYPE="${project_type}"
 MAX_CALLS_PER_HOUR=100
 CLAUDE_TIMEOUT_MINUTES=15
 CLAUDE_OUTPUT_FORMAT="json"
+WRITE_TIMEOUT_MINUTES=8
 
 # Tool permissions
 # Comma-separated list of allowed tools
@@ -707,6 +708,7 @@ BEADS_FILTER="status:open"
 CB_NO_PROGRESS_THRESHOLD=3
 CB_SAME_ERROR_THRESHOLD=5
 CB_OUTPUT_DECLINE_THRESHOLD=70
+CB_READ_ONLY_TIMEOUT_THRESHOLD=2
 RALPHRCEOF
 }
 
 
@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# Write heartbeat monitor for Ralph (#146)
+# Kills the Claude driver early if no project files are modified within a
+# configurable timeout window.  Prevents the agent from burning the entire
+# CLAUDE_TIMEOUT_MINUTES on read-only exploration loops.
+
+# Start a background monitor that watches for project file modifications.
+#
+# Args:
+#   $1 - project_dir: root of the project to monitor
+#   $2 - claude_pid:  PID of the portable_timeout wrapper to kill on timeout
+#   $3 - timeout_minutes: minutes without a write before killing the driver
+#   $4 - check_interval: seconds between filesystem checks (default 30)
+#
+# Env:
+#   _HEARTBEAT_TIMEOUT_SECS_OVERRIDE: if set, overrides timeout_minutes * 60
+#                                      (test-support only)
+start_write_heartbeat() {
+    local project_dir=$1 claude_pid=$2 timeout_minutes=$3 check_interval=${4:-30}
+    local ralph_dir="$project_dir/.ralph"
+    local marker="$ralph_dir/.heartbeat_marker"
+    local timeout_secs
+
+    if [[ -n "${_HEARTBEAT_TIMEOUT_SECS_OVERRIDE:-}" ]]; then
+        timeout_secs=$_HEARTBEAT_TIMEOUT_SECS_OVERRIDE
+    else
+        timeout_secs=$((timeout_minutes * 60))
+    fi
+
+    # Clean stale state from previous runs
+    rm -f "$ralph_dir/.write_heartbeat_triggered" \
+          "$ralph_dir/.write_heartbeat_seen"
+
+    # Timestamp marker — find -newer compares against this
+    touch "$marker"
+
+    (
+        set +e  # Prevent inherited set -e from killing monitor on find errors
+        trap 'exit 0' TERM
+
+        local elapsed=0 write_seen=""
+
+        while kill -0 "$claude_pid" 2>/dev/null; do
+            sleep "$check_interval"
+            elapsed=$((elapsed + check_interval))
+
+            # Check for project file modifications (skip once detected)
+            if [[ -z "$write_seen" ]]; then
+                local changed
+                changed=$(find "$project_dir" \
+                    -path "$project_dir/.ralph" -prune -o \
+                    -path "$project_dir/.git" -prune -o \
+                    -path "$project_dir/node_modules" -prune -o \
+                    -path "$project_dir/.next" -prune -o \
+                    -path "$project_dir/dist" -prune -o \
+                    -path "$project_dir/build" -prune -o \
+                    -path "$project_dir/__pycache__" -prune -o \
+                    -path "$project_dir/.turbo" -prune -o \
+                    -newer "$marker" -type f -print -quit 2>/dev/null)
+
+                if [[ -n "$changed" ]]; then
+                    touch "$ralph_dir/.write_heartbeat_seen"
+                    write_seen=true
+                fi
+            fi
+
+            # Timeout: re-check PID is alive (may have exited during sleep),
+            # then write marker BEFORE kill to eliminate race with wait
+            if [[ $elapsed -ge $timeout_secs && -z "$write_seen" ]]; then
+                if kill -0 "$claude_pid" 2>/dev/null; then
+                    echo "true" > "$ralph_dir/.write_heartbeat_triggered"
+                    kill "$claude_pid" 2>/dev/null  # GNU timeout propagates SIGTERM to child
+                fi
+                exit 0
+            fi
+        done
+    ) &
+
+    echo $! > "$ralph_dir/.write_heartbeat_pid"
+}
+
+# Stop the heartbeat monitor and clean up marker files.
+# Safe to call even if no monitor is running.
+stop_write_heartbeat() {
+    local ralph_dir="${RALPH_DIR:-.ralph}"
+    local pid_file="$ralph_dir/.write_heartbeat_pid"
+
+    if [[ -f "$pid_file" ]]; then
+        local pid
+        pid=$(cat "$pid_file")
+        if [[ -n "$pid" ]] && kill -0 "$pid" 2>/dev/null; then
+            kill "$pid" 2>/dev/null || true
+            wait "$pid" 2>/dev/null || true
+        fi
+        rm -f "$pid_file"
+    fi
+
+    rm -f "$ralph_dir/.heartbeat_marker" "$ralph_dir/.write_heartbeat_seen"
+}
+
+# Check whether the most recent execution was killed by the heartbeat.
+# Returns 0 (true) if the timeout marker exists.
+# Does NOT delete the marker — the caller is responsible for cleanup.
+was_write_heartbeat_timeout() {
+    local ralph_dir="${RALPH_DIR:-.ralph}"
+    [[ -f "$ralph_dir/.write_heartbeat_triggered" ]]
+}