Simplify restart: hook launches claude -p directly, no PID watching

Removed find_claude_pid, build_restarter_code, schedule_restart.
New launch_new_session just spawns 'claude -p' as a detached process.
continue_mode=True: writes HANDOFF.md + launches new session.
continue_mode=False: warns only, session continues through compaction.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jvalin17

hooks/auto_handoff.py

@@ -1,11 +1,9 @@
-"""Auto-handoff — hook-written HANDOFF.md for agent-independent continuation.
+"""Auto-handoff — hook-written HANDOFF.md and session restart.
 
-Called by session_monitor when hard stop triggers. The hook writes
-the handoff directly so the agent cannot prevent, delay, or fake it.
-When continue_mode is on, also schedules a background restart.
+Called by session_monitor when context pressure is high and continue_mode
+is on. Writes HANDOFF.md and launches a new claude session in the background.
 """
 
-import os
 import re
 import shutil
 import subprocess
@@ -47,20 +45,10 @@ def write_auto_handoff(
     previous_handoff: str,
     git_log: str,
 ) -> None:
-    """Write HANDOFF.md from hook — agent-independent handoff.
-
-    Args:
-        handoff_path: Path to write HANDOFF.md
-        state: SessionState (duck-typed — needs exchanges, tool_calls,
-               cumulative_output_bytes, compactions, last_tool_sequence)
-        stop_reason: Human-readable reason for the stop
-        previous_handoff: Content of existing HANDOFF.md (empty string if none)
-        git_log: Output of git log --oneline
-    """
+    """Write HANDOFF.md from hook — agent-independent handoff."""
     goal, session_number = parse_handoff_header(previous_handoff)
     next_session = session_number + 1
 
-    # Build last tool sequence summary
     tool_summary = ""
     if state.last_tool_sequence:
         tool_lines = []
@@ -127,110 +115,41 @@ def get_git_log(max_entries: int = 10) -> str:
         return ""
 
 
-def find_claude_pid() -> int:
-    """Walk up the process tree to find the claude process PID.
-
-    Hooks run as: claude → bash → python3 (this process).
-    os.getppid() gives bash, which dies when the hook exits.
-    We need the actual claude PID so the restarter waits for it.
-    Returns 0 if not found.
-    """
-    try:
-        pid = os.getppid()  # start from our parent
-        for _ in range(10):  # walk up max 10 levels
-            result = subprocess.run(
-                ["ps", "-p", str(pid), "-o", "ppid=,comm="],
-                capture_output=True, text=True, timeout=5,
-            )
-            if result.returncode != 0:
-                break
-            parts = result.stdout.strip().split(None, 1)
-            if len(parts) < 2:
-                break
-            ppid, comm = int(parts[0]), parts[1]
-            if "claude" in comm.lower():
-                return pid  # this PID is the claude process
-            if ppid <= 1:
-                break
-            pid = ppid
-    except (OSError, ValueError, subprocess.TimeoutExpired):
-        pass
-    return 0
-
-
-def build_restarter_code(
-    wait_pid: int,
-    session_dir: str,
-    project_dir: str,
-    claude_bin: str,
-) -> str:
-    """Build the Python source for the background restarter process.
-
-    Separated from schedule_restart for testability.
-    """
-    return f"""
-import os, shutil, subprocess, sys, time
-# Wait for the claude process to exit
-wait_pid = {wait_pid}
-for _ in range(600):
-    try:
-        os.kill(wait_pid, 0)
-        time.sleep(1)
-    except OSError:
-        break
-# Brief pause to let Claude fully shut down
-time.sleep(2)
-# Clean session state
-session_dir = {session_dir!r}
-if os.path.isdir(session_dir):
-    shutil.rmtree(session_dir, ignore_errors=True)
-# Relaunch
-prompt = "Read HANDOFF.md and continue from where the previous session left off."
-cmd = [{claude_bin!r}, "-p", prompt, "--output-format", "json", "--dangerously-skip-permissions"]
-env = {{**os.environ, "AGENT_TOOLKIT_CONTINUE": "true"}}
-subprocess.run(cmd, cwd={project_dir!r}, env=env)
-"""
-
-
-def schedule_restart(project_dir: Path) -> None:
-    """Spawn a detached background process that restarts claude after this session exits.
+def launch_new_session(project_dir: Path) -> bool:
+    """Launch a new claude session in the background.
 
-    Finds the actual claude process (not the bash intermediary), then spawns
-    a restarter that waits for it to exit, cleans .session/, and relaunches.
+    Spawns `claude -p` as a detached process. The new session reads
+    HANDOFF.md and continues. No PID-watching — just fire and forget.
+    Returns True if launched, False if claude not found.
     """
     claude_bin = shutil.which("claude")
     if not claude_bin:
-        sys.stderr.write("auto_handoff: claude not on PATH, cannot schedule restart\n")
-        return
-
-    claude_pid = find_claude_pid()
-    if claude_pid == 0:
-        sys.stderr.write("auto_handoff: could not find claude process in tree\n")
-        return
-
-    restarter_code = build_restarter_code(
-        wait_pid=claude_pid,
-        session_dir=str(project_dir / ".session"),
-        project_dir=str(project_dir),
-        claude_bin=claude_bin,
-    )
+        sys.stderr.write("auto_handoff: claude not on PATH, cannot launch new session\n")
+        return False
+
+    prompt = "Read HANDOFF.md and continue from where the previous session left off."
+    cmd = [
+        claude_bin, "-p", prompt,
+        "--output-format", "json",
+        "--dangerously-skip-permissions",
+    ]
+
     try:
         subprocess.Popen(
-            [sys.executable, "-c", restarter_code],
+            cmd,
+            cwd=str(project_dir),
             start_new_session=True,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
         )
+        return True
     except OSError as exc:
-        sys.stderr.write(f"auto_handoff: failed to schedule restart: {{exc}}\n")
+        sys.stderr.write(f"auto_handoff: failed to launch session: {exc}\n")
+        return False
 
 
 def trigger_auto_handoff(state, stop_reason: str) -> None:
-    """Trigger hook-written handoff. Called when hard stop fires.
-
-    Reads existing HANDOFF.md, gets git log, writes the new handoff,
-    and schedules a background restart if continue_mode is on.
-    """
+    """Write HANDOFF.md and launch a new session if continue_mode is on."""
     handoff_path = Path("HANDOFF.md")
     previous_handoff = ""
     if handoff_path.exists():
@@ -250,4 +169,4 @@ def trigger_auto_handoff(state, stop_reason: str) -> None:
     )
 
     if getattr(state, "continue_mode", False):
-        schedule_restart(Path.cwd())
+        launch_new_session(Path.cwd())

hooks/session_limits.py

@@ -1,10 +1,10 @@
-"""Session limit enforcement — warn only, never stop.
+"""Session limit enforcement.
 
-Sessions continue through compaction. Limits produce warnings
-so the agent prioritizes current work over starting new tasks.
-No handoff, no stop, no restart — compaction handles context pressure.
+continue_mode=True: write HANDOFF.md and launch a new session.
+continue_mode=False: warn only, session continues through compaction.
 """
 
+from auto_handoff import trigger_auto_handoff
 from session_state import (
     FALLBACK_MAX_EXCHANGES,
     HARD_THRESHOLD_BYTES,
@@ -17,18 +17,26 @@
 def apply_session_limits(state: SessionState) -> tuple:
     """Apply byte/time limits. Returns (state, response_message).
 
-    Never stops the session. Warns once when thresholds are hit
-    so the agent wraps up current work instead of starting new tasks.
-    Compaction handles context pressure naturally.
+    continue_mode=True: writes HANDOFF.md and launches new claude session.
+    continue_mode=False: warns only, session continues through compaction.
     """
     triggered, stop_reason = check_thresholds(state)
 
+    if triggered and state.continue_mode and not state.warned:
+        state.warned = True
+        trigger_auto_handoff(state, stop_reason)
+        return state, (
+            f"SESSION LIMIT: {stop_reason}. "
+            f"HANDOFF.md written. A new session is being launched. "
+            f"Wrap up current work."
+        )
+
     if triggered and not state.warned:
         state.warned = True
         return state, (
             f"SESSION LIMIT: {stop_reason}. "
-            f"The session will continue (compaction handles context pressure). "
-            f"Quality may degrade. Wrap up current work before starting new tasks."
+            f"The session continues (compaction handles context pressure). "
+            f"Quality may degrade. Wrap up current work."
         )
 
     if should_warn(state) and not state.warned:

tests/test_session_monitor.py

@@ -16,7 +16,9 @@
 sys.path.insert(0, str(Path(__file__).parent.parent / "hooks"))
 
 from auto_handoff import (
+    launch_new_session,
     parse_handoff_header,
+    trigger_auto_handoff,
     write_auto_handoff,
 )
 from session_monitor import (
@@ -1297,21 +1299,38 @@ def test_compaction_does_not_write_handoff(self, tmp_path, monkeypatch):
         # Handoff should NOT be rewritten
         assert handoff_path.read_text() == original_content
 
-    def test_byte_limit_does_not_write_handoff(self, tmp_path, monkeypatch):
-        """Byte limit warns but does NOT write handoff."""
+    def test_byte_limit_no_handoff_without_continue(self, tmp_path, monkeypatch):
+        """Without continue_mode, byte limit warns but does NOT write handoff."""
         handoff_path = tmp_path / "HANDOFF.md"
         monkeypatch.chdir(tmp_path)
 
         state = SessionState(
             session_start=int(time.time()),
             cumulative_output_bytes=HARD_THRESHOLD_BYTES + 1,
+            continue_mode=False,
         )
         state, response, blocked = handle_pre_tool_use(
             state, tool_name="Read", file_path="foo.py", command=""
         )
-        assert state.stopped == 0
         assert blocked is False
-        assert not handoff_path.exists()  # No handoff written
+        assert not handoff_path.exists()
+
+    def test_byte_limit_writes_handoff_with_continue(self, tmp_path, monkeypatch):
+        """With continue_mode, byte limit writes HANDOFF.md and launches new session."""
+        monkeypatch.chdir(tmp_path)
+
+        state = SessionState(
+            session_start=int(time.time()),
+            cumulative_output_bytes=HARD_THRESHOLD_BYTES + 1,
+            continue_mode=True,
+        )
+        with patch("auto_handoff.launch_new_session"):
+            state, response, blocked = handle_pre_tool_use(
+                state, tool_name="Read", file_path="foo.py", command=""
+            )
+        assert blocked is False
+        assert (tmp_path / "HANDOFF.md").exists()
+        assert "new session" in response.lower() or "launched" in response.lower()
 
 
 # --- Time-based session limit (F1) ---
@@ -1439,6 +1458,47 @@ def test_disabled_time_limit_skips_stale_check(self, tmp_path):
         assert state.session_start == old_start
 
 
+class TestLaunchNewSession:
+    """launch_new_session spawns claude as a detached process."""
+
+    def test_launches_claude(self, tmp_path):
+        with patch("auto_handoff.shutil.which", return_value="/usr/bin/claude"), \
+             patch("auto_handoff.subprocess.Popen") as mock_popen:
+            result = launch_new_session(tmp_path)
+        assert result is True
+        mock_popen.assert_called_once()
+        cmd = mock_popen.call_args[0][0]
+        assert "/usr/bin/claude" in cmd
+        assert "-p" in cmd
+        assert mock_popen.call_args[1]["start_new_session"] is True
+
+    def test_skips_when_claude_missing(self, tmp_path):
+        with patch("auto_handoff.shutil.which", return_value=None), \
+             patch("auto_handoff.subprocess.Popen") as mock_popen:
+            result = launch_new_session(tmp_path)
+        assert result is False
+        mock_popen.assert_not_called()
+
+    def test_continue_mode_triggers_handoff_and_launch(self, tmp_path, monkeypatch):
+        """When continue_mode=True and limit triggers, writes handoff and launches."""
+        monkeypatch.chdir(tmp_path)
+        (tmp_path / "HANDOFF.md").write_text("# HANDOFF\n\n## Goal\n\nGoal\n")
+
+        state = SessionState(session_start=int(time.time()), continue_mode=True)
+        with patch("auto_handoff.launch_new_session") as mock_launch:
+            trigger_auto_handoff(state, "test reason")
+        mock_launch.assert_called_once()
+
+    def test_no_continue_mode_skips_launch(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+        (tmp_path / "HANDOFF.md").write_text("# HANDOFF\n\n## Goal\n\nGoal\n")
+
+        state = SessionState(session_start=int(time.time()), continue_mode=False)
+        with patch("auto_handoff.launch_new_session") as mock_launch:
+            trigger_auto_handoff(state, "test reason")
+        mock_launch.assert_not_called()
+
+
 class TestTimeLimitWarnsOnly:
     """Time limits warn but never stop the session."""