Session continuity can hijack active Claude Code sessions

[dionny]

Bug Description

Ralph's session continuity feature can accidentally resume an actively in-use Claude Code session, causing ralph to inject PROMPT.md into an ongoing human conversation instead of doing autonomous work.

Root Cause

Multiple issues were found:

1. --continue flag hijacks any active session

Ralph uses --continue which resumes the "most recent conversation in the current directory" - this can be ANY active Claude Code session, not just Ralph's own sessions.

Fix: Use --resume <session_id> with an explicit session ID instead of --continue.

2. log_status writes to stdout, corrupting function return values

The init_claude_session() function returns session IDs via stdout, but log_status() also writes to stdout. This causes log messages like "[INFO] Starting new Claude session" to be captured as the session ID.

Fix: Change log_status to write to stderr (>&2).

3. Ctrl+C takes too long to stop Ralph

When interrupted, the cleanup function doesn't kill the Claude subprocess, causing hangs.

Fix: Track Claude PID globally and kill it in the cleanup handler.

4. Live output only shows tool names, not details

The jq filter only shows ⚡ [ToolName] without showing what the tool is actually doing.

Fix: Enhanced jq filter to show tool inputs as they stream.

Steps to Reproduce

1. Open a Claude Code session in a terminal and start working
2. In that same session (or same directory), run any ralph command
3. Ralph saves the current session ID
4. Run ralph --monitor from another terminal
5. Ralph resumes the user's active session instead of starting fresh
6. User sees PROMPT.md injected into their conversation

The Fix

See PR #153 for the complete fix. Key changes to ralph_loop.sh:

# Before (buggy):
CLAUDE_CMD_ARGS+=("--continue")

# After (fixed):
if [[ -n "$session_id" ]]; then
    CLAUDE_CMD_ARGS+=("--resume" "$session_id")
fi

# Before (buggy):
echo -e "${color}[$timestamp] [$level] $message${NC}"

# After (fixed):
echo -e "${color}[$timestamp] [$level] $message${NC}" >&2

Environment

• ralph-claude-code version: 0.11.2
• OS: macOS
• Shell: zsh

[coderabbitai]

📝 CodeRabbit Plan Mode

Generate an implementation plan and prompts that you can use with your favorite coding agent.

• Create Plan

Examples

• Example 1
• Example 2

---

🔗 Related PRs

#58 - fix(loop): replace non-existent --prompt-file with -p flag [merged]
#66 - feat(session): add session lifecycle management with auto-reset triggers [merged]
#84 - feat(session): implement session expiration with configurable timeout [merged]
#133 - fix(test): robust variable init in session continuity test 199 [merged]
#142 - feat(exit): detect permission denials and halt loop (Issue #101) [merged]

---

🧪 Issue enrichment is currently in open beta.

You can configure auto-planning by selecting labels in the issue_enrichment configuration.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!

[dionny]

Additional Finding: Global Session Tracking

The problem is worse than initially described. Even after:

• Running ralph --reset-session
• Clearing all .ralph/.ralph_session* files
• Running ralph --monitor from a completely different terminal window

Ralph STILL hijacked the active Claude Code session.

Root Cause

Ralph uses the --continue flag with Claude CLI, which resumes the globally last active session - not just the session ID stored in .ralph/.ralph_session.

The Claude CLI maintains its own global session tracking (likely in ~/.claude/ or similar), and --continue resumes whatever session was last active system-wide, regardless of which terminal or directory it was started from.

The Result

If a user has Claude Code open in Terminal A, and runs ralph --monitor in Terminal B:

1. Ralph sends PROMPT.md to Claude CLI with --continue
2. Claude CLI resumes the session in Terminal A (the user's active session)
3. The user sees Ralph's PROMPT.md injected into their conversation
4. Ralph sees responses from the user's conversation, not autonomous work
5. Circuit breaker triggers "no progress"
6. Complete chaos

Workaround

Running ralph --no-continue should force a fresh session, but this defeats the session continuity feature entirely.

Suggested Fix

Ralph should either:

1. Use explicit session IDs with Claude CLI instead of relying on --continue
2. Check if a session is active before attempting to continue it
3. Default to --no-continue and only resume sessions that Ralph itself started
4. Use a Ralph-specific session namespace that can't collide with interactive sessions

The current behavior makes Ralph unusable if you have ANY Claude Code session open anywhere on your system.

[traycerai]

Plan

Observations

The session continuity bug stems from four interconnected issues in file:ralph_loop.sh: (1) --continue flag resumes any active Claude session globally instead of Ralph's specific session, (2) log_status() writes to stdout, corrupting function return values like session IDs, (3) cleanup handler doesn't terminate Claude subprocess causing slow Ctrl+C, and (4) live output jq filter only displays tool names without showing actual tool inputs/parameters.

Approach

The fix requires switching from --continue to --resume <session_id> for explicit session targeting, redirecting all log_status() output to stderr to preserve function return values, tracking Claude subprocess PID globally for proper cleanup, and enhancing the jq filter to extract and display tool inputs from stream events. This ensures Ralph maintains its own isolated session without hijacking user's active Claude Code sessions.

Implementation Steps

1. Fix log_status() to Write to Stderr

File: file:ralph_loop.sh

Modify the log_status() function (line 308-324) to redirect output to stderr instead of stdout:

• Change line 322 from:

  echo -e "${color}[$timestamp] [$level] $message${NC}"

  to:

  echo -e "${color}[$timestamp] [$level] $message${NC}" >&2

This prevents log messages from corrupting function return values that use stdout (like init_claude_session() at line 673-707).

2. Replace --continue with --resume <session_id>

File: file:ralph_loop.sh

Update the build_claude_command() function (lines 929-982):

• Replace lines 966-969:

  # Add session continuity flag
  if [[ "$CLAUDE_USE_CONTINUE" == "true" ]]; then
      CLAUDE_CMD_ARGS+=("--continue")
  fi

  with:

  # Add session continuity with explicit session ID
  if [[ "$CLAUDE_USE_CONTINUE" == "true" && -n "$session_id" ]]; then
      CLAUDE_CMD_ARGS+=("--resume" "$session_id")
  fi

This ensures Ralph only resumes its own sessions using explicit session IDs, preventing hijacking of active user sessions.

3. Track Claude Subprocess PID Globally

File: file:ralph_loop.sh

Add global PID tracking and update cleanup handler:

• Add global variable declaration near line 924 (after declare -a CLAUDE_CMD_ARGS=()):

  # Global PID for Claude subprocess (for cleanup)
  CLAUDE_PID=""

• In execute_claude_code() function, capture Claude PID in both live mode and background mode:

  • For live mode (around line 1100), after the pipeline execution, capture the PID before the pipeline starts
  • For background mode (around line 1183), update the existing claude_pid=$! to also set CLAUDE_PID=$!

• Update cleanup() function (lines 1308-1314) to kill Claude subprocess:

  cleanup() {
      log_status "INFO" "Ralph loop interrupted. Cleaning up..."
      
      # Kill Claude subprocess if running
      if [[ -n "$CLAUDE_PID" ]] && kill -0 "$CLAUDE_PID" 2>/dev/null; then
          log_status "INFO" "Terminating Claude subprocess (PID: $CLAUDE_PID)..."
          kill "$CLAUDE_PID" 2>/dev/null || true
          wait "$CLAUDE_PID" 2>/dev/null || true
      fi
      
      reset_session "manual_interrupt"
      update_status "$loop_count" "$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")" "interrupted" "stopped"
      exit 0
  }

4. Enhance jq Filter for Live Output

File: file:ralph_loop.sh

Update the jq filter (lines 1080-1093) to show tool inputs and results:

Replace the existing filter with:

local jq_filter='
    if .type == "stream_event" then
        if .event.type == "content_block_delta" and .event.delta.type == "text_delta" then
            .event.delta.text
        elif .event.type == "content_block_start" and .event.content_block.type == "tool_use" then
            "\n\n⚡ [" + .event.content_block.name + "]"
            + (if .event.content_block.input then 
                "\n   Input: " + (.event.content_block.input | tostring | .[0:200])
               else "" end)
            + "\n"
        elif .event.type == "content_block_delta" and .event.delta.type == "tool_use_delta" then
            if .event.delta.partial_json then
                "   " + .event.delta.partial_json
            else empty end
        elif .event.type == "content_block_stop" then
            "\n"
        else
            empty
        end
    else
        empty
    end'

This displays tool names, inputs (truncated to 200 chars), and streaming tool results for better visibility into what Claude is doing.

5. Update Session Initialization Logic

File: file:ralph_loop.sh

Verify that init_claude_session() (lines 673-707) properly returns session IDs via stdout. Since log_status() now writes to stderr, the function should work correctly without modifications. However, ensure all log statements within this function use log_status() and not direct echo commands.

6. Testing Considerations

Files: file:tests/unit/test_session_continuity.bats

The existing test suite at file:tests/unit/test_session_continuity.bats should be updated to verify:

• Test that --resume is used instead of --continue (update test at line 274-280)
• Test that log_status() writes to stderr (add new test)
• Test that cleanup kills Claude subprocess (add new test)
• Test that session IDs are properly extracted without log pollution (existing tests should pass)

Run the test suite to ensure all session continuity tests pass after implementing the changes.

7. Documentation Updates

Files: file:CLAUDE.md, file:README.md

Update documentation to reflect:

• Session continuity now uses explicit session IDs instead of global --continue
• Ctrl+C properly terminates Claude subprocess
• Live mode shows detailed tool inputs and outputs
• Troubleshooting section explaining that Ralph maintains isolated sessions

Sequence Diagram

sequenceDiagram
    participant User
    participant Ralph as ralph_loop.sh
    participant Claude as Claude CLI
    participant Session as Session Files

    User->>Ralph: Start ralph --monitor
    Ralph->>Session: Check .ralph_session
    Session-->>Ralph: Return session_id (or empty)
    
    alt Session exists and valid
        Ralph->>Ralph: init_claude_session() returns session_id
        Ralph->>Ralph: build_claude_command() with --resume session_id
    else No session or expired
        Ralph->>Ralph: init_claude_session() returns empty
        Ralph->>Ralph: build_claude_command() without --resume
    end
    
    Ralph->>Claude: Execute with explicit session ID
    Claude-->>Ralph: Stream output with session_id
    Ralph->>Session: Save session_id to .claude_session_id
    
    User->>Ralph: Ctrl+C (SIGINT)
    Ralph->>Claude: Kill subprocess (CLAUDE_PID)
    Ralph->>Session: reset_session("manual_interrupt")
    Ralph-->>User: Clean exit

Loading

Import In IDE

🤖 Prompt for AI Agents

## Observations

The session continuity bug stems from four interconnected issues in `file:ralph_loop.sh`: (1) `--continue` flag resumes any active Claude session globally instead of Ralph's specific session, (2) `log_status()` writes to stdout, corrupting function return values like session IDs, (3) cleanup handler doesn't terminate Claude subprocess causing slow Ctrl+C, and (4) live output jq filter only displays tool names without showing actual tool inputs/parameters.

## Approach

The fix requires switching from `--continue` to `--resume <session_id>` for explicit session targeting, redirecting all `log_status()` output to stderr to preserve function return values, tracking Claude subprocess PID globally for proper cleanup, and enhancing the jq filter to extract and display tool inputs from stream events. This ensures Ralph maintains its own isolated session without hijacking user's active Claude Code sessions.

## Implementation Steps

### 1. Fix `log_status()` to Write to Stderr

**File:** `file:ralph_loop.sh`

Modify the `log_status()` function (line 308-324) to redirect output to stderr instead of stdout:

- Change line 322 from:
  ```bash
  echo -e "${color}[$timestamp] [$level] $message${NC}"
  ```
  to:
  ```bash
  echo -e "${color}[$timestamp] [$level] $message${NC}" >&2
  ```

This prevents log messages from corrupting function return values that use stdout (like `init_claude_session()` at line 673-707).

### 2. Replace `--continue` with `--resume <session_id>`

**File:** `file:ralph_loop.sh`

Update the `build_claude_command()` function (lines 929-982):

- Replace lines 966-969:
  ```bash
  # Add session continuity flag
  if [[ "$CLAUDE_USE_CONTINUE" == "true" ]]; then
      CLAUDE_CMD_ARGS+=("--continue")
  fi
  ```
  
  with:
  ```bash
  # Add session continuity with explicit session ID
  if [[ "$CLAUDE_USE_CONTINUE" == "true" && -n "$session_id" ]]; then
      CLAUDE_CMD_ARGS+=("--resume" "$session_id")
  fi
  ```

This ensures Ralph only resumes its own sessions using explicit session IDs, preventing hijacking of active user sessions.

### 3. Track Claude Subprocess PID Globally

**File:** `file:ralph_loop.sh`

Add global PID tracking and update cleanup handler:

- Add global variable declaration near line 924 (after `declare -a CLAUDE_CMD_ARGS=()`):
  ```bash
  # Global PID for Claude subprocess (for cleanup)
  CLAUDE_PID=""
  ```

- In `execute_claude_code()` function, capture Claude PID in both live mode and background mode:
  - For live mode (around line 1100), after the pipeline execution, capture the PID before the pipeline starts
  - For background mode (around line 1183), update the existing `claude_pid=$!` to also set `CLAUDE_PID=$!`

- Update `cleanup()` function (lines 1308-1314) to kill Claude subprocess:
  ```bash
  cleanup() {
      log_status "INFO" "Ralph loop interrupted. Cleaning up..."
      
      # Kill Claude subprocess if running
      if [[ -n "$CLAUDE_PID" ]] && kill -0 "$CLAUDE_PID" 2>/dev/null; then
          log_status "INFO" "Terminating Claude subprocess (PID: $CLAUDE_PID)..."
          kill "$CLAUDE_PID" 2>/dev/null || true
          wait "$CLAUDE_PID" 2>/dev/null || true
      fi
      
      reset_session "manual_interrupt"
      update_status "$loop_count" "$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")" "interrupted" "stopped"
      exit 0
  }
  ```

### 4. Enhance jq Filter for Live Output

**File:** `file:ralph_loop.sh`

Update the jq filter (lines 1080-1093) to show tool inputs and results:

Replace the existing filter with:
```bash
local jq_filter='
    if .type == "stream_event" then
        if .event.type == "content_block_delta" and .event.delta.type == "text_delta" then
            .event.delta.text
        elif .event.type == "content_block_start" and .event.content_block.type == "tool_use" then
            "\n\n⚡ [" + .event.content_block.name + "]"
            + (if .event.content_block.input then 
                "\n   Input: " + (.event.content_block.input | tostring | .[0:200])
               else "" end)
            + "\n"
        elif .event.type == "content_block_delta" and .event.delta.type == "tool_use_delta" then
            if .event.delta.partial_json then
                "   " + .event.delta.partial_json
            else empty end
        elif .event.type == "content_block_stop" then
            "\n"
        else
            empty
        end
    else
        empty
    end'
```

This displays tool names, inputs (truncated to 200 chars), and streaming tool results for better visibility into what Claude is doing.

### 5. Update Session Initialization Logic

**File:** `file:ralph_loop.sh`

Verify that `init_claude_session()` (lines 673-707) properly returns session IDs via stdout. Since `log_status()` now writes to stderr, the function should work correctly without modifications. However, ensure all log statements within this function use `log_status()` and not direct `echo` commands.

### 6. Testing Considerations

**Files:** `file:tests/unit/test_session_continuity.bats`

The existing test suite at `file:tests/unit/test_session_continuity.bats` should be updated to verify:

- Test that `--resume` is used instead of `--continue` (update test at line 274-280)
- Test that `log_status()` writes to stderr (add new test)
- Test that cleanup kills Claude subprocess (add new test)
- Test that session IDs are properly extracted without log pollution (existing tests should pass)

Run the test suite to ensure all session continuity tests pass after implementing the changes.

### 7. Documentation Updates

**Files:** `file:CLAUDE.md`, `file:README.md`

Update documentation to reflect:
- Session continuity now uses explicit session IDs instead of global `--continue`
- Ctrl+C properly terminates Claude subprocess
- Live mode shows detailed tool inputs and outputs
- Troubleshooting section explaining that Ralph maintains isolated sessions

## Sequence Diagram

```mermaid
sequenceDiagram
    participant User
    participant Ralph as ralph_loop.sh
    participant Claude as Claude CLI
    participant Session as Session Files

    User->>Ralph: Start ralph --monitor
    Ralph->>Session: Check .ralph_session
    Session-->>Ralph: Return session_id (or empty)
    
    alt Session exists and valid
        Ralph->>Ralph: init_claude_session() returns session_id
        Ralph->>Ralph: build_claude_command() with --resume session_id
    else No session or expired
        Ralph->>Ralph: init_claude_session() returns empty
        Ralph->>Ralph: build_claude_command() without --resume
    end
    
    Ralph->>Claude: Execute with explicit session ID
    Claude-->>Ralph: Stream output with session_id
    Ralph->>Session: Save session_id to .claude_session_id
    
    User->>Ralph: Ctrl+C (SIGINT)
    Ralph->>Claude: Kill subprocess (CLAUDE_PID)
    Ralph->>Session: reset_session("manual_interrupt")
    Ralph-->>User: Clean exit
```

---

Execution Information

Branch: main
Commit: 02dbb07

---

💡 Tips

Supported Commands (Inside Comments)

• Use @traycerai generate to iterate on the previous version of the implementation plan.

Supported Commands (Inside Description)

• Add @traycerai ignore anywhere in the ticket description to prevent this ticket from being processed.
• Add @traycerai branch:<branch-name> anywhere in the ticket description to specify the target branch for the implementation plan.

Community

• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.

[dionny]

Fix Submitted

PR #153 addresses all the issues described above:

1. Session hijacking - Uses --resume <session_id> instead of --continue
2. Log pollution - log_status now writes to stderr
3. Ctrl+C slow - Tracks and kills Claude subprocess on interrupt
4. Verbose output - Shows tool inputs/results in live mode

The fix has been tested locally and works correctly - Ralph now runs in its own session without hijacking active Claude Code sessions.

[frankbria]

Fixed in commit 42f5df6.

Ralph now uses --resume <session_id> instead of --continue, ensuring it only resumes its own sessions and won't hijack active Claude Code sessions in the same directory.

Credit to @dionny for PR #153.