overcode 0.3.2__tar.gz → 0.3.3__tar.gz

{overcode-0.3.2/src/overcode.egg-info → overcode-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overcode
-Version: 0.3.2
+Version: 0.3.3
 Summary: A supervisor for managing multiple Claude Code instances in tmux
 Author: Mike Bond
 Project-URL: Homepage, https://github.com/mkb23/overcode

{overcode-0.3.2 → overcode-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "overcode"
-version = "0.3.2"
+version = "0.3.3"
 description = "A supervisor for managing multiple Claude Code instances in tmux"
 authors = [
     {name = "Mike Bond"}

{overcode-0.3.2 → overcode-0.3.3}/src/overcode/claude_config.py

@@ -137,6 +137,23 @@ class ClaudeConfigEditor:
                         results.append((event, cmd))
         return results
 
+    # ----- Hook detection -----
+
+    @staticmethod
+    def are_overcode_hooks_installed() -> bool:
+        """Check if core overcode hooks are installed at user level.
+
+        Requires at least UserPromptSubmit, Stop, and PostToolUse hooks
+        to consider hooks mode viable.
+        """
+        editor = ClaudeConfigEditor.user_level()
+        try:
+            editor.load()
+        except (ValueError, FileNotFoundError):
+            return False
+        core_events = ("UserPromptSubmit", "Stop", "PostToolUse")
+        return all(editor.has_hook(event, "overcode hook-handler") for event in core_events)
+
     # ----- Permission management -----
 
     def add_permission(self, tool_pattern: str) -> bool:

{overcode-0.3.2 → overcode-0.3.3}/src/overcode/cli/agent.py

@@ -970,9 +970,10 @@ def show(
     else:
         # Daemon not running — fall back to direct detection
         from ..status_detector_factory import create_status_detector
+        from ..settings import resolve_detection_mode
         detector = create_status_detector(
             session,
-            strategy="hooks" if sess.hook_status_detection else "polling",
+            strategy=resolve_detection_mode(session),
         )
         status, activity, pane_content_raw = detector.detect_status(sess)
 

{overcode-0.3.2 → overcode-0.3.3}/src/overcode/cli/split.py

@@ -491,11 +491,10 @@ def tmux_layout(
         rprint("  tmux set -g terminal-features ''")
         return
 
-    # Verify agents session exists
+    # Create agents session if it doesn't exist (#397)
     if not _tmux_check("has-session", "-t", session):
-        rprint(f"[red]No tmux session '{session}' found.[/red]")
-        rprint(f"[dim]Launch some agents first, or create it: tmux new-session -d -s {session}[/dim]")
-        raise typer.Exit(1)
+        rprint(f"[dim]Creating tmux session '{session}'...[/dim]")
+        _tmux("new-session", "-d", "-s", session)
 
     # --- Toggle key selection (runs if not yet configured) ---
     from ..config import get_tmux_toggle_key, set_tmux_toggle_key

{overcode-0.3.2 → overcode-0.3.3}/src/overcode/history_reader.py

@@ -33,8 +33,12 @@ CLAUDE_PROJECTS_PATH = Path.home() / ".claude" / "projects"
 
 # Model name → context window size in tokens.
 # Default 200K for unknown models.  Update as new models ship.
+# Claude Code with 1M context reports the same model ID — we detect
+# the actual context size from token counts at runtime and update here
+# for the models known to support extended context.
 MODEL_CONTEXT_WINDOWS: Dict[str, int] = {
-    "claude-opus-4-6": 200_000,
+    "claude-opus-4-6": 1_000_000,
+    "claude-sonnet-4-6": 1_000_000,
     "claude-sonnet-4-5-20250929": 200_000,
     "claude-haiku-4-5-20251001": 200_000,
     "claude-3-5-sonnet-20241022": 200_000,
@@ -45,6 +49,32 @@ MODEL_CONTEXT_WINDOWS: Dict[str, int] = {
 }
 DEFAULT_CONTEXT_WINDOW = 200_000
 
+# Model ID → human-readable short name for display
+MODEL_SHORT_NAMES: Dict[str, str] = {
+    "claude-opus-4-6": "Op4.6",
+    "claude-sonnet-4-6": "Sn4.6",
+    "claude-sonnet-4-5-20250929": "Sn4.5",
+    "claude-haiku-4-5-20251001": "Hk4.5",
+    "claude-3-5-sonnet-20241022": "Sn3.5",
+    "claude-3-5-haiku-20241022": "Hk3.5",
+    "claude-3-opus-20240229": "Op3",
+    "claude-3-sonnet-20240229": "Sn3",
+    "claude-3-haiku-20240307": "Hk3",
+}
+
+
+def model_short_name(model: Optional[str]) -> str:
+    """Return a short display name for a model ID.
+
+    Examples:
+        "claude-opus-4-6" → "Op4.6"
+        "claude-haiku-4-5-20251001" → "Hk4.5"
+        "unknown-model" → "unknown-model"
+    """
+    if not model:
+        return ""
+    return MODEL_SHORT_NAMES.get(model, model)
+
 
 def model_context_window(model: Optional[str]) -> int:
     """Return the context window size for a given model name.

{overcode-0.3.2 → overcode-0.3.3}/src/overcode/hook_handler.py

@@ -25,8 +25,11 @@ logger = logging.getLogger(__name__)
 # All hooks that overcode installs
 OVERCODE_HOOKS: list[tuple[str, str]] = [
     ("UserPromptSubmit", "overcode hook-handler"),
+    ("PreToolUse", "overcode hook-handler"),
     ("PostToolUse", "overcode hook-handler"),
+    ("PostToolUseFailure", "overcode hook-handler"),
     ("Stop", "overcode hook-handler"),
+    ("StopFailure", "overcode hook-handler"),
     ("PermissionRequest", "overcode hook-handler"),
     ("SessionEnd", "overcode hook-handler"),
 ]

{overcode-0.3.2 → overcode-0.3.3}/src/overcode/hook_status_detector.py

@@ -1,30 +1,33 @@
 """
 Hook-based status detector for Claude sessions (#5).
 
-Reads hook state files written by Claude Code hooks (UserPromptSubmit, Stop,
-PermissionRequest, PostToolUse, SessionEnd) to determine agent status without
-tmux pane scraping.
+Reads hook state files written by Claude Code hooks (UserPromptSubmit,
+PreToolUse, PostToolUse, Stop, PermissionRequest, SessionEnd) to determine
+agent status without tmux pane scraping.
 
 Design:
-- Hook state is authoritative for STATUS when fresh (< stale_threshold_seconds).
-- Pane content is read for enrichment (activity description) but never for status.
-- Falls back to PollingStatusDetector when hook state is missing or stale.
-- One source of truth at any given moment: either hooks or polling, never both.
+- Hook state is the sole authority for status. No polling fallback.
+- Running-state hooks (UserPromptSubmit, PreToolUse, PostToolUse) are
+  trusted indefinitely — Claude will send Stop or SessionEnd when done.
+- Pane content is read only for activity enrichment, never for status.
 """
 
 import json
 import os
+import subprocess
 import time
 from pathlib import Path
-from typing import Optional, Tuple, TYPE_CHECKING
+from typing import Dict, Optional, Tuple, TYPE_CHECKING
 
 from .status_constants import (
     DEFAULT_CAPTURE_LINES,
+    STATUS_CAPTURE_LINES,
     STATUS_RUNNING,
     STATUS_BUSY_SLEEPING,
     STATUS_WAITING_USER,
     STATUS_WAITING_OVERSIGHT,
     STATUS_TERMINATED,
+    STATUS_ERROR,
 )
 from .status_patterns import (
     is_sleep_command,
@@ -43,14 +46,15 @@ if TYPE_CHECKING:
 # Hook event → status mapping
 _HOOK_STATUS_MAP = {
     "UserPromptSubmit": STATUS_RUNNING,
+    "PreToolUse": STATUS_RUNNING,
+    "PostToolUse": STATUS_RUNNING,
+    "PostToolUseFailure": STATUS_RUNNING,  # Tool failed but agent is still working
     "Stop": STATUS_WAITING_USER,
+    "StopFailure": STATUS_ERROR,  # API error ended the turn (purple indicator)
     "PermissionRequest": STATUS_WAITING_USER,
-    "PostToolUse": STATUS_RUNNING,
     "SessionEnd": STATUS_TERMINATED,
 }
 
-DEFAULT_STALE_THRESHOLD = 120  # seconds
-
 
 class HookStatusDetector:
     """Detects session status from hook state files.
@@ -62,10 +66,11 @@ class HookStatusDetector:
         {
             "event": "UserPromptSubmit",
             "timestamp": 1234567890.123,
-            "tool_name": "Read"  // optional, for PostToolUse
+            "tool_name": "Read"  // optional, for PostToolUse/PreToolUse
         }
 
-    When hook state is missing or stale (>120s), falls back to polling.
+    No polling fallback. If no hook state file exists, the detector checks
+    whether the tmux window is alive and returns a sensible default.
     """
 
     # Re-export status constants for backward compat (same interface as PollingStatusDetector)
@@ -79,14 +84,17 @@ class HookStatusDetector:
         tmux: "TmuxInterface" = None,
         patterns: "StatusPatterns" = None,
         state_dir: Optional[Path] = None,
-        stale_threshold_seconds: float = DEFAULT_STALE_THRESHOLD,
+        # Legacy params kept for API compat — ignored
+        stale_threshold_seconds: float = 0,
         polling_fallback=None,
     ):
         self.tmux_session = tmux_session
         self.capture_lines = DEFAULT_CAPTURE_LINES
         self._tmux = tmux
         self._patterns = patterns
-        self._stale_threshold = stale_threshold_seconds
+        # Diagnostic phase tracking (same interface as PollingStatusDetector)
+        self._last_detect_phase: Dict[str, str] = {}
+        self._content_changed: Dict[str, bool] = {}
 
         # Resolve state directory — must match hook_handler._get_hook_state_path()
         if state_dir is not None:
@@ -98,19 +106,6 @@ class HookStatusDetector:
             else:
                 self._state_dir = Path.home() / ".overcode" / "sessions" / tmux_session
 
-        # Shared or lazy-created polling fallback.  When the dispatcher injects
-        # its polling detector, hash state and phase tracking are shared.
-        self._polling_fallback = polling_fallback
-
-    def _get_polling_fallback(self):
-        """Return (or lazily create) the polling fallback detector."""
-        if self._polling_fallback is None:
-            from .status_detector import PollingStatusDetector
-            self._polling_fallback = PollingStatusDetector(
-                self.tmux_session, tmux=self._tmux, patterns=self._patterns
-            )
-        return self._polling_fallback
-
     def _hook_state_path(self, session_name: str) -> Path:
         """Get the hook state file path for a session."""
         return self._state_dir / f"hook_state_{session_name}.json"
@@ -120,7 +115,8 @@ class HookStatusDetector:
 
         Returns:
             Parsed dict with 'event', 'timestamp', optional 'tool_name',
-            or None if file is missing, corrupt, or stale.
+            or None if file is missing or corrupt.
+            No staleness check — running hooks are trusted indefinitely.
         """
         path = self._hook_state_path(session_name)
         try:
@@ -135,58 +131,61 @@ class HookStatusDetector:
         if "event" not in data or "timestamp" not in data:
             return None
 
-        # Check staleness
+        # Validate timestamp is a number
         try:
-            ts = float(data["timestamp"])
+            float(data["timestamp"])
         except (TypeError, ValueError):
             return None
 
-        age = time.time() - ts
-        if age > self._stale_threshold:
-            return None
-
         return data
 
     def get_pane_content(self, window: str, num_lines: int = 0) -> Optional[str]:
-        """Get pane content via the polling detector's tmux interface."""
-        fallback = self._get_polling_fallback()
-        fallback.capture_lines = self.capture_lines
-        return fallback.get_pane_content(window, num_lines)
+        """Get pane content via tmux capture-pane."""
+        if self._tmux:
+            return self._tmux.capture_pane(
+                self.tmux_session, window,
+                lines=num_lines or self.capture_lines
+            )
+        # Direct tmux subprocess fallback
+        lines_arg = num_lines or self.capture_lines
+        try:
+            result = subprocess.run(
+                ["tmux", "capture-pane", "-t", f"{self.tmux_session}:{window}",
+                 "-p", "-S", f"-{lines_arg}"],
+                capture_output=True, text=True, timeout=5,
+            )
+            return result.stdout if result.returncode == 0 else None
+        except (subprocess.TimeoutExpired, OSError):
+            return None
 
     def detect_status(self, session: "Session", num_lines: int = 0) -> Tuple[str, str, str]:
         """Detect session status using hook state files.
 
-        When fresh hook state exists, uses that for status determination.
-        Still reads pane content for activity enrichment.
-        Falls back to full polling when hook state is missing or stale.
+        No polling fallback. When no hook state exists, checks if the
+        tmux window is alive and returns a sensible default.
 
         Returns:
             Tuple of (status, current_activity, pane_content)
         """
         hook_state = self._read_hook_state(session.name)
 
-        # Record phase on the shared polling detector for diagnostics
-        polling = self._get_polling_fallback()
-
         if hook_state is None:
-            # No hook state or stale → full polling fallback
-            # Phase tracking is set by the polling detector itself.
-            return polling.detect_status(session, num_lines=num_lines)
-
-        # Hook state is fresh → use it for status
+            # No hook state file — agent hasn't triggered a hook yet.
+            # Check if the window exists to distinguish fresh-start from terminated.
+            pane_content = self.get_pane_content(session.tmux_window, num_lines=num_lines)
+            if pane_content is None:
+                self._last_detect_phase[session.id] = "hook:no_state+no_window"
+                return STATUS_TERMINATED, "Window no longer exists", ""
+            # Window alive, no hooks yet — assume waiting for input
+            self._last_detect_phase[session.id] = "hook:no_state"
+            return STATUS_WAITING_USER, "Waiting for first hook event", pane_content
+
+        # Hook state exists — use it for status
         event = hook_state.get("event", "")
 
         if event == "SessionEnd":
-            # SessionEnd fires both on actual exit AND on /clear.
-            # We know Claude reported ending, so do a targeted pane check:
-            # - Shell prompt on last line → actual exit → TERMINATED
-            # - Claude's prompt (› or >) on last line → /clear → fall back to polling
-            #
-            # We can't use the full polling _is_shell_prompt() here because it
-            # rejects shell prompts when Claude's ⏺ output is in the last 5 lines,
-            # which is always the case right after exit.
-            polling._last_detect_phase[session.id] = f"hook:SessionEnd"
-            return self._detect_session_end_status(session)
+            self._last_detect_phase[session.id] = "hook:SessionEnd"
+            return self._detect_session_end_status(session, num_lines)
 
         status = _HOOK_STATUS_MAP.get(event, STATUS_WAITING_USER)
 
@@ -200,7 +199,7 @@ class HookStatusDetector:
         # Check for busy-sleeping: agent is "running" but executing a sleep command (#289)
         sleep_dur = None
         if status == STATUS_RUNNING:
-            sleep_dur = self._find_sleep_duration(pane_content, hook_state)
+            sleep_dur = self._find_sleep_duration(hook_state)
             if sleep_dur is not None:
                 status = STATUS_BUSY_SLEEPING
 
@@ -212,24 +211,19 @@ class HookStatusDetector:
             activity = f"Sleeping {format_duration(sleep_dur)}" if sleep_dur else "Sleeping"
 
         # Record hook phase for diagnostics
-        polling._last_detect_phase[session.id] = f"hook:{event}"
+        self._last_detect_phase[session.id] = f"hook:{event}"
 
         return status, activity, pane_content
 
-    def _detect_session_end_status(self, session: "Session") -> Tuple[str, str, str]:
+    def _detect_session_end_status(self, session: "Session", num_lines: int = 0) -> Tuple[str, str, str]:
         """Determine status after a SessionEnd hook event.
 
         SessionEnd fires both on actual exit AND on /clear. We distinguish
         by checking the last line of the pane:
         - Shell prompt (user@host path %) → actual exit → TERMINATED
-        - Claude's prompt (› or >) → /clear was used → fall back to polling
-
-        Unlike the full polling _is_shell_prompt(), this does NOT reject shell
-        prompts when Claude's ⏺ output appears in nearby lines — that output
-        is always present right after exit and is irrelevant once we know
-        SessionEnd fired.
+        - Claude's prompt (› or >) → /clear was used → WAITING_USER
         """
-        pane_content = self.get_pane_content(session.tmux_window) or ""
+        pane_content = self.get_pane_content(session.tmux_window, num_lines=num_lines) or ""
         clean = strip_ansi(pane_content)
         lines = [l.strip() for l in clean.strip().split('\n') if l.strip()]
 
@@ -241,45 +235,61 @@ class HookStatusDetector:
         if is_shell_prompt(last_line):
             return STATUS_TERMINATED, "Claude exited - shell prompt", pane_content
 
-        # No shell prompt → likely /clear, fall back to full polling
-        return self._get_polling_fallback().detect_status(session)
-
-    def _find_sleep_duration(self, pane_content: str, hook_state: dict) -> int | None:
-        """Find sleep duration from pane content or hook state (#289).
+        # No shell prompt → likely /clear, agent is waiting for input
+        return STATUS_WAITING_USER, "Waiting for user input", pane_content
 
-        Checks two signals:
-        1. Pane content for sleep commands (e.g., "Running Bash("sleep 30")")
-        2. Hook state tool_input for sleep commands (from PostToolUse)
+    def _find_sleep_duration(self, hook_state: dict) -> int | None:
+        """Find sleep duration from hook state's tool_input (#289).
 
-        Returns:
-            Sleep duration in seconds, or None if not sleeping.
-            A return value of 0 means sleeping but duration unknown.
+        PreToolUse and PostToolUse include tool_input with the Bash command.
+        Parse the command directly — no pane scraping needed.
         """
-        # Check pane content for sleep patterns
-        clean = strip_ansi(pane_content)
-        for line in clean.strip().split('\n')[-10:]:
-            dur = extract_sleep_duration(line)
-            if dur is not None:
-                return dur
-
-        # Check tool_input from hook state (PostToolUse includes tool_input)
         tool_input = hook_state.get("tool_input")
         if isinstance(tool_input, dict):
             command = tool_input.get("command", "")
             dur = extract_sleep_duration(command)
             if dur is not None:
                 return dur
-
         return None
 
+    @staticmethod
+    def _parse_bash_activity(hook_state: dict) -> str | None:
+        """Parse a Bash tool_input command into a concise activity string.
+
+        Returns a human-readable summary of what the Bash command does,
+        or None if the command isn't parseable or isn't Bash.
+        """
+        if hook_state.get("tool_name") != "Bash":
+            return None
+        tool_input = hook_state.get("tool_input")
+        if not isinstance(tool_input, dict):
+            return None
+        command = tool_input.get("command", "")
+        if not command:
+            return None
+        # Truncate long commands
+        if len(command) > 80:
+            command = command[:77] + "..."
+        return f"Bash: {command}"
+
     def _build_activity(self, event: str, hook_state: dict, pane_content: str, session: "Session" = None) -> str:
         """Build an activity description from hook event and pane content."""
-        if event == "PostToolUse":
+        if event in ("PreToolUse", "PostToolUse"):
+            # For Bash, show the actual command for better visibility
+            bash_activity = self._parse_bash_activity(hook_state)
+            if bash_activity:
+                return bash_activity
             tool_name = hook_state.get("tool_name", "")
             if tool_name:
                 return f"Using {tool_name}"
             return "Running tool"
 
+        if event == "PostToolUseFailure":
+            tool_name = hook_state.get("tool_name", "")
+            if tool_name:
+                return f"Tool failed: {tool_name}"
+            return "Tool failed"
+
         if event == "UserPromptSubmit":
             return "Processing prompt"
 
@@ -288,6 +298,9 @@ class HookStatusDetector:
                 return "Waiting for oversight report"
             return "Waiting for user input"
 
+        if event == "StopFailure":
+            return "API error"
+
         if event == "PermissionRequest":
             return "Permission: approval required"
 

{overcode-0.3.2 → overcode-0.3.3}/src/overcode/monitor_daemon.py

@@ -276,9 +276,12 @@ class MonitorDaemon:
 
         # Dependencies (allow injection for testing)
         self.session_manager = session_manager or SessionManager()
+        from .settings import resolve_detection_mode
+        detection_mode = resolve_detection_mode(tmux_session)
         self.detector = StatusDetectorDispatcher(
             tmux_session,
             polling_detector=status_detector,
+            mode=detection_mode,
         )
 
         # Presence tracking (graceful degradation)
@@ -299,6 +302,7 @@ class MonitorDaemon:
         self.previous_states: Dict[str, str] = {}
         self.last_state_times: Dict[str, datetime] = {}
         self.operation_start_times: Dict[str, datetime] = {}
+        self._last_hook_phases: Dict[str, str] = {}  # session_id → last logged phase
 
         # Stats sync throttling - None forces immediate sync on first loop
         self._last_stats_sync: Optional[datetime] = None
@@ -505,6 +509,19 @@ class MonitorDaemon:
             ):
                 continue
 
+            # In hooks mode, double-check the hook state right before sending.
+            # The agent may have started working between the daemon's last
+            # detection and now (e.g., user typed something). Sending a
+            # heartbeat into a running session corrupts the prompt (#374).
+            if self.detector.mode == "hooks":
+                hook_detector = self.detector.hooks
+                hook_state = hook_detector._read_hook_state(session.name)
+                if hook_state:
+                    event = hook_state.get("event", "")
+                    if event in ("UserPromptSubmit", "PreToolUse", "PostToolUse"):
+                        self.log.info(f"[{session.name}] Heartbeat skipped (hook says {event})")
+                        continue
+
             # Send the heartbeat instruction
             if send_text_to_tmux_window(
                 session.tmux_session,
@@ -869,6 +886,12 @@ class MonitorDaemon:
 
     def _tick(self, now: datetime) -> None:
         """Execute one monitoring loop iteration."""
+        # Re-read detection mode in case the TUI toggled it via K hotkey
+        from .settings import resolve_detection_mode
+        current_mode = resolve_detection_mode(self.tmux_session)
+        if self.detector.mode != current_mode:
+            self.detector.mode = current_mode
+            self.log.info(f"Detection mode changed to: {current_mode}")
         sessions = [s for s in self.session_manager.list_sessions()
                     if s.tmux_session == self.tmux_session]
         if not self._legacy_windows_migrated:
@@ -926,6 +949,9 @@ class MonitorDaemon:
                 # Detect status - dispatches per-session via dispatcher (#5)
                 status, activity, pane_content = self.detector.detect_status(session)
 
+                # Log hook events when they change (diagnostic visibility)
+                self._log_hook_event(session, status, activity)
+
                 # Extract PR number from pane content
                 if pane_content:
                     pr = extract_pr_number(pane_content)
@@ -1005,6 +1031,26 @@ class MonitorDaemon:
 
         return session_states, all_waiting_user
 
+    def _log_hook_event(self, session, status: str, activity: str) -> None:
+        """Log hook events to the daemon log when they change.
+
+        Reads the detector's _last_detect_phase diagnostic and logs
+        when a new hook event fires for an agent, showing the agent name,
+        hook event, and resulting status.
+        """
+        # Get the phase from whichever detector is active
+        detector = self.detector.hooks if self.detector.mode == "hooks" else self.detector.polling
+        phases = getattr(detector, '_last_detect_phase', {})
+        current_phase = phases.get(session.id, "")
+
+        prev_phase = self._last_hook_phases.get(session.id)
+        if current_phase and current_phase != prev_phase:
+            self._last_hook_phases[session.id] = current_phase
+            # Format: "agent-name  hook:PostToolUse → running (Using Read)"
+            self.log.info(
+                f"{session.name}  {current_phase} → {status} ({activity})"
+            )
+
     def _compute_subtree_costs(self, session_states):
         """Compute subtree cost (self + all descendants) for each parent agent."""
         by_name = {s.name: s for s in session_states}

{overcode-0.3.2 → overcode-0.3.3}/src/overcode/settings.py

@@ -407,6 +407,38 @@ def get_web_server_port_path(session: str) -> Path:
     return get_session_dir(session) / "web_server.port"
 
 
+def get_detection_mode_path(session: str) -> Path:
+    """Get the detection mode file path for a specific session."""
+    return get_session_dir(session) / "detection_mode"
+
+
+def read_detection_mode(session: str) -> str:
+    """Read the global detection mode ('hooks' or 'polling').
+
+    Returns 'auto' if no explicit mode is set (auto-detect on startup).
+    """
+    try:
+        return get_detection_mode_path(session).read_text().strip()
+    except (FileNotFoundError, IOError):
+        return "auto"
+
+
+def write_detection_mode(session: str, mode: str) -> None:
+    """Write the global detection mode for daemon/TUI synchronisation."""
+    path = get_detection_mode_path(session)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(mode)
+
+
+def resolve_detection_mode(session: str) -> str:
+    """Resolve 'auto' to 'hooks' or 'polling' based on hook installation."""
+    mode = read_detection_mode(session)
+    if mode in ("hooks", "polling"):
+        return mode
+    from .claude_config import ClaudeConfigEditor
+    return "hooks" if ClaudeConfigEditor.are_overcode_hooks_installed() else "polling"
+
+
 def get_diagnostics_dir(session: str) -> Path:
     """Get the diagnostics directory for a specific session."""
     return get_session_dir(session) / "diagnostics"

{overcode-0.3.2 → overcode-0.3.3}/src/overcode/status_detector.py

@@ -172,12 +172,18 @@ class PollingStatusDetector:
         # prompt detection.
         #
         # HOWEVER: Claude Code always renders the ❯ prompt as UI chrome, even
-        # while actively working (#393). When active indicators like
-        # "esc to interrupt" are present, the prompt is just decoration —
-        # trust the active indicators over the prompt char.
+        # while actively working (#393). When Claude IS active, "esc to
+        # interrupt" appears at the bottom of the pane — either as a
+        # standalone line or appended to the ⏵⏵ permissions status bar.
+        # We check only the last 2 lines for this, because historical
+        # thinking output (✻ Twisting…, ⎿ Running…) persists in scrollback
+        # above the prompt and would false-match general active indicators.
         if content_changed:
-            has_active_indicator = matches_any(last_few, self.patterns.active_indicators)
-            if not has_active_indicator:
+            status_bar_active = any(
+                "esc to interrupt" in line.lower()
+                for line in last_lines[-2:]
+            )
+            if not status_bar_active:
                 prompt_result = self._detect_user_prompt(last_lines, content)
                 if prompt_result is not None:
                     self._last_detect_phase[session.id] = "P5+P12:prompt_override"
@@ -351,7 +357,21 @@ class PollingStatusDetector:
         Distinguishes:
         - Empty prompt `>` or `› ` = waiting for user input
         - User input `> some text` with no Claude response = stalled
+
+        Claude Code always renders the ❯ prompt as UI chrome, even while
+        actively working (#393). When active indicators are present in the
+        last lines, the prompt is just decoration — skip prompt detection.
         """
+        # If "esc to interrupt" appears at the bottom of the pane, Claude
+        # is actively working — the prompt and user input are just UI chrome.
+        # Only check the last 2 lines to avoid matching historical thinking
+        # output (✻, Running…) that persists in scrollback (#393).
+        if any(
+            "esc to interrupt" in line.lower()
+            for line in last_lines[-2:]
+        ):
+            return None
+
         # Check for empty prompt or autocomplete suggestion
         for line in last_lines[-4:]:
             stripped = line.strip()