overcode 0.1.0__py3-none-any.whl

overcode/daemon.py

@@ -0,0 +1,1184 @@
+#!/usr/bin/env python3
+"""
+DEPRECATED: Legacy Overcode Daemon
+
+This module is deprecated. Use instead:
+- overcode.monitor_daemon - For metrics tracking and status monitoring
+- overcode.supervisor_daemon - For autonomous Claude orchestration
+
+The CLI commands 'overcode daemon start/stop/status' are also deprecated.
+Use 'overcode monitor-daemon' and 'overcode supervisor-daemon' instead.
+
+This file is kept for backwards compatibility with existing CLI commands
+and will be removed in a future version.
+"""
+
+import os
+import tempfile
+import time
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, List, Dict
+from rich.console import Console
+from rich.text import Text
+from rich.theme import Theme
+from .session_manager import SessionManager
+from .status_detector import StatusDetector
+from .tmux_manager import TmuxManager
+from .pid_utils import is_process_running, get_process_pid, write_pid_file, remove_pid_file
+from .status_constants import (
+    STATUS_RUNNING,
+    STATUS_WAITING_USER,
+    get_status_color,
+    get_status_emoji,
+)
+from .daemon_state import DaemonState, MODE_MONITOR, MODE_SUPERVISE
+from .status_history import log_agent_status, read_agent_status_history
+from .history_reader import get_session_stats
+from .settings import DAEMON, get_activity_signal_path
+
+
+# Interval settings (in seconds)
+INTERVAL_FAST = 10       # When active or agents working
+INTERVAL_SLOW = 300      # When all agents need user input (5 min)
+INTERVAL_IDLE = 3600     # When no agents at all (1 hour)
+
+# File locations
+OVERCODE_DIR = Path.home() / '.overcode'
+DAEMON_STATE_FILE = OVERCODE_DIR / 'daemon_state.json'
+DAEMON_LOG_FILE = OVERCODE_DIR / 'daemon.log'
+DAEMON_PID_FILE = OVERCODE_DIR / 'daemon.pid'
+ACTIVITY_SIGNAL_FILE = OVERCODE_DIR / 'activity_signal'
+AGENT_STATUS_HISTORY_FILE = OVERCODE_DIR / 'agent_status_history.csv'
+
+
+def is_daemon_running() -> bool:
+    """Check if the daemon process is currently running.
+
+    Returns True if PID file exists and process is alive.
+    Can be called from other modules (e.g., TUI).
+    """
+    return is_process_running(DAEMON_PID_FILE)
+
+
+def get_daemon_pid() -> Optional[int]:
+    """Get the daemon PID if running, None otherwise."""
+    return get_process_pid(DAEMON_PID_FILE)
+
+
+def stop_daemon() -> bool:
+    """Stop the daemon process if running.
+
+    Returns True if daemon was stopped, False if it wasn't running.
+    Also cleans up stale PID files.
+
+    Note: Uses quick stop (just SIGTERM, no wait) for responsive CLI.
+    """
+    import signal
+
+    pid = get_process_pid(DAEMON_PID_FILE)
+    if pid is None:
+        # Clean up stale PID file if exists
+        remove_pid_file(DAEMON_PID_FILE)
+        return False
+
+    try:
+        os.kill(pid, signal.SIGTERM)
+        remove_pid_file(DAEMON_PID_FILE)
+        return True
+    except (OSError, ProcessLookupError):
+        remove_pid_file(DAEMON_PID_FILE)
+        return False
+
+
+def signal_activity(session: str = None) -> None:
+    """Signal user activity to the daemon (called by TUI on keypress).
+
+    Creates a signal file that the daemon checks each loop.
+
+    Args:
+        session: tmux session name (default: from config)
+    """
+    if session is None:
+        session = DAEMON.default_tmux_session
+    signal_path = get_activity_signal_path(session)
+    try:
+        signal_path.parent.mkdir(parents=True, exist_ok=True)
+        signal_path.touch()
+    except OSError:
+        pass  # Best effort
+
+
+def check_activity_signal() -> bool:
+    """Check for and consume the activity signal (called by daemon).
+
+    Returns True if signal was present (and deletes the file).
+    """
+    if ACTIVITY_SIGNAL_FILE.exists():
+        try:
+            ACTIVITY_SIGNAL_FILE.unlink()
+            return True
+        except OSError:
+            pass
+    return False
+
+
+def _write_pid_file() -> None:
+    """Write current PID to file."""
+    write_pid_file(DAEMON_PID_FILE)
+
+
+def _remove_pid_file() -> None:
+    """Remove PID file."""
+    remove_pid_file(DAEMON_PID_FILE)
+
+
+# Rich theme for daemon logs
+DAEMON_THEME = Theme({
+    "info": "cyan",
+    "warn": "yellow",
+    "error": "bold red",
+    "success": "bold green",
+    "daemon_claude": "magenta",
+    "dim": "dim white",
+    "highlight": "bold white",
+})
+
+
+class DaemonLogger:
+    """Rich-based logger for daemon with pretty console output and file logging."""
+
+    def __init__(self, log_file: Path = DAEMON_LOG_FILE):
+        self.log_file = log_file
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+        self.console = Console(theme=DAEMON_THEME, force_terminal=True)
+        # Track seen lines by content to avoid duplicates when output scrolls
+        self._seen_daemon_claude_lines: set = set()
+
+    def _write_to_file(self, message: str, level: str):
+        """Write plain text to log file."""
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        line = f"[{timestamp}] [{level}] {message}"
+        with open(self.log_file, 'a') as f:
+            f.write(line + '\n')
+
+    def info(self, message: str):
+        """Log info message."""
+        self._write_to_file(message, "INFO")
+        self.console.print(f"[dim]{datetime.now().strftime('%H:%M:%S')}[/dim] [info]INFO[/info]  {message}")
+
+    def warn(self, message: str):
+        """Log warning message."""
+        self._write_to_file(message, "WARN")
+        self.console.print(f"[dim]{datetime.now().strftime('%H:%M:%S')}[/dim] [warn]WARN[/warn]  {message}")
+
+    def error(self, message: str):
+        """Log error message."""
+        self._write_to_file(message, "ERROR")
+        self.console.print(f"[dim]{datetime.now().strftime('%H:%M:%S')}[/dim] [error]ERROR[/error] {message}")
+
+    def success(self, message: str):
+        """Log success message."""
+        self._write_to_file(message, "INFO")
+        self.console.print(f"[dim]{datetime.now().strftime('%H:%M:%S')}[/dim] [success]OK[/success]    {message}")
+
+    def daemon_claude_output(self, lines: List[str]):
+        """Log daemon claude output, showing only new lines.
+
+        Uses content-based tracking (set) instead of positional comparison,
+        which correctly handles terminal scrolling where lines shift up.
+        """
+        new_lines = []
+
+        for line in lines:
+            stripped = line.strip()
+            if not stripped:
+                continue
+
+            # Check if we've seen this line before
+            if stripped not in self._seen_daemon_claude_lines:
+                new_lines.append(stripped)
+                self._seen_daemon_claude_lines.add(stripped)
+
+        # Limit the set size to prevent unbounded memory growth
+        # Keep only the most recent lines by clearing old entries periodically
+        if len(self._seen_daemon_claude_lines) > 500:
+            # Keep lines from current capture to maintain context
+            current_lines = {line.strip() for line in lines if line.strip()}
+            self._seen_daemon_claude_lines = current_lines
+
+        if new_lines:
+            # Log new output with daemon claude styling
+            for line in new_lines:
+                self._write_to_file(f"[DAEMON_CLAUDE] {line}", "INFO")
+                # Style the output based on content
+                if line.startswith('✓') or 'success' in line.lower():
+                    self.console.print(f"  [success]│[/success] {line}")
+                elif line.startswith('✗') or 'error' in line.lower() or 'fail' in line.lower():
+                    self.console.print(f"  [error]│[/error] {line}")
+                elif line.startswith('>') or line.startswith('$'):
+                    self.console.print(f"  [highlight]│[/highlight] {line}")
+                else:
+                    self.console.print(f"  [daemon_claude]│[/daemon_claude] {line}")
+
+    def section(self, title: str):
+        """Print a section divider."""
+        self._write_to_file(f"=== {title} ===", "INFO")
+        self.console.print()
+        self.console.rule(f"[bold]{title}[/bold]", style="dim")
+
+    def status_summary(self, total: int, green: int, non_green: int, loop: int):
+        """Print a status summary line."""
+        status_text = Text()
+        status_text.append(f"Loop #{loop}: ", style="dim")
+        status_text.append(f"{total} agents ", style="highlight")
+        status_text.append("(", style="dim")
+        status_text.append(f"{green} green", style="success")
+        status_text.append(", ", style="dim")
+        status_text.append(f"{non_green} non-green", style="warn" if non_green else "dim")
+        status_text.append(")", style="dim")
+
+        self._write_to_file(f"Loop #{loop}: {total} agents ({green} green, {non_green} non-green)", "INFO")
+        self.console.print(f"[dim]{datetime.now().strftime('%H:%M:%S')}[/dim] ", end="")
+        self.console.print(status_text)
+
+    def agent_status(self, name: str, status: str, activity: str):
+        """Log individual agent status."""
+        style = get_status_color(status)
+
+        self._write_to_file(f"  {name}: {status} - {activity[:60]}", "INFO")
+        self.console.print(f"  [{style}]●[/{style}] [bold]{name}[/bold]: [{style}]{status}[/{style}] - [dim]{activity[:60]}[/dim]")
+
+
+class Daemon:
+    """Background daemon that auto-launches daemon claude when needed"""
+
+    # Special window name for daemon's claude (not tracked in sessions.json)
+    DAEMON_CLAUDE_WINDOW_NAME = "_daemon_claude"
+
+    # Rough cost estimates per interaction (USD)
+    # Based on typical Claude Code interaction costs
+    COST_PER_INTERACTION = {
+        "opus": 0.05,    # ~$0.05 per interaction for Opus
+        "sonnet": 0.01,  # ~$0.01 per interaction for Sonnet
+        "default": 0.03  # Default estimate
+    }
+
+    def __init__(
+        self,
+        tmux_session: str = "agents",
+        session_manager: SessionManager = None,
+        status_detector: StatusDetector = None,
+        tmux_manager: TmuxManager = None,
+        logger: "DaemonLogger" = None,
+        mode: str = MODE_SUPERVISE,
+    ):
+        """Initialize the daemon.
+
+        Args:
+            tmux_session: Name of the tmux session to manage
+            session_manager: Optional SessionManager for dependency injection (testing)
+            status_detector: Optional StatusDetector for dependency injection (testing)
+            tmux_manager: Optional TmuxManager for dependency injection (testing)
+            logger: Optional DaemonLogger for dependency injection (testing)
+            mode: Daemon mode - MODE_MONITOR (stats only) or MODE_SUPERVISE (full)
+        """
+        self.tmux_session = tmux_session
+        self.session_manager = session_manager if session_manager else SessionManager()
+        self.status_detector = status_detector if status_detector else StatusDetector(tmux_session)
+        self.tmux = tmux_manager if tmux_manager else TmuxManager(tmux_session)
+        self.daemon_claude_window: Optional[int] = None
+        self.state = DaemonState()
+        self.state.mode = mode
+        self.last_controller_check: Optional[datetime] = None
+        self.controller_line_count = 0
+        self.log = logger if logger else DaemonLogger()
+        # Track previous states to detect transitions
+        self.previous_states: Dict[str, str] = {}  # session_id -> last known status
+        # Track when operations started (for timing)
+        self.operation_start_times: Dict[str, datetime] = {}  # session_id -> when went non-running
+        # Track when daemon claude was launched (for counting interventions)
+        self.daemon_claude_launch_time: Optional[datetime] = None
+        # Track last state change time per session for state time tracking
+        self.last_state_times: Dict[str, datetime] = {}  # session_id -> last state change time
+
+    def track_session_stats(self, session, status: str) -> None:
+        """Track session state transitions and update stats.
+
+        Called for each session on each daemon loop to detect:
+        - Transitions from non-running to running (= 1 interaction completed)
+        - Operation duration (time spent waiting)
+        - State time accumulation (green_time_seconds, non_green_time_seconds)
+        """
+        session_id = session.id
+        now = datetime.now()
+
+        # Get previous status (default to current if first time seeing this session)
+        prev_status = self.previous_states.get(session_id, status)
+
+        # Track state time accumulation
+        self._update_state_time(session, status, now)
+
+        # Detect state transitions
+        was_running = prev_status == STATUS_RUNNING
+        is_running = status == STATUS_RUNNING
+
+        # Session went from running to waiting (operation started)
+        if was_running and not is_running:
+            self.operation_start_times[session_id] = now
+
+        # Session went from waiting back to running (operation completed)
+        if not was_running and is_running:
+            # Calculate operation time if we have a start time
+            op_duration = None
+            if session_id in self.operation_start_times:
+                start_time = self.operation_start_times[session_id]
+                op_duration = (now - start_time).total_seconds()
+                del self.operation_start_times[session_id]
+
+            # Update operation times for latency tracking (keep last 100)
+            current_stats = session.stats
+            op_times = list(current_stats.operation_times)
+            if op_duration is not None and op_duration > 0:
+                op_times.append(op_duration)
+                op_times = op_times[-100:]  # Keep last 100
+
+                # Save updated operation times
+                self.session_manager.update_stats(
+                    session_id,
+                    operation_times=op_times,
+                    last_activity=now.isoformat()
+                )
+
+                self.log.info(f"[{session.name}] Operation completed ({op_duration:.1f}s)")
+
+        # Update previous state for next check
+        self.previous_states[session_id] = status
+
+    def _update_state_time(self, session, status: str, now: datetime) -> None:
+        """Update green_time_seconds and non_green_time_seconds for a session.
+
+        Called each loop to accumulate time in current state.
+        """
+        session_id = session.id
+        current_stats = session.stats
+
+        # Get last recorded time for this session
+        last_time = self.last_state_times.get(session_id)
+        if last_time is None:
+            # First time seeing this session, initialize from state_since if available
+            if current_stats.state_since:
+                try:
+                    last_time = datetime.fromisoformat(current_stats.state_since)
+                except ValueError:
+                    last_time = now
+            else:
+                last_time = now
+            self.last_state_times[session_id] = last_time
+            return  # Don't accumulate on first observation
+
+        # Calculate time elapsed since last check
+        elapsed = (now - last_time).total_seconds()
+        if elapsed <= 0:
+            return
+
+        # Accumulate time based on current state
+        green_time = current_stats.green_time_seconds
+        non_green_time = current_stats.non_green_time_seconds
+
+        if status == STATUS_RUNNING:
+            green_time += elapsed
+        else:
+            non_green_time += elapsed
+
+        # Update state tracking if state changed
+        prev_status = self.previous_states.get(session_id, status)
+        state_since = current_stats.state_since
+        if prev_status != status:
+            state_since = now.isoformat()
+        elif not state_since:
+            # Initialize state_since if never set (e.g., new session)
+            state_since = now.isoformat()
+
+        # Save updated times
+        self.session_manager.update_stats(
+            session_id,
+            current_state=status,
+            state_since=state_since,
+            green_time_seconds=green_time,
+            non_green_time_seconds=non_green_time,
+        )
+
+        # Update tracking time
+        self.last_state_times[session_id] = now
+
+    def sync_claude_code_stats(self, session) -> None:
+        """Sync token/interaction stats from Claude Code history files.
+
+        Reads from ~/.claude/projects/ to get actual token usage and
+        persists to SessionStats for historical reference.
+        """
+        try:
+            stats = get_session_stats(session)
+            if stats is None:
+                return
+
+            now = datetime.now()
+
+            # Calculate total tokens
+            total_tokens = (
+                stats.input_tokens +
+                stats.output_tokens +
+                stats.cache_creation_tokens +
+                stats.cache_read_tokens
+            )
+
+            # Estimate cost (rough approximation)
+            # Using ~$3/1M input, ~$15/1M output for Claude
+            cost_estimate = (
+                (stats.input_tokens / 1_000_000) * 3.0 +
+                (stats.output_tokens / 1_000_000) * 15.0 +
+                (stats.cache_creation_tokens / 1_000_000) * 3.75 +
+                (stats.cache_read_tokens / 1_000_000) * 0.30
+            )
+
+            self.session_manager.update_stats(
+                session.id,
+                interaction_count=stats.interaction_count,
+                total_tokens=total_tokens,
+                input_tokens=stats.input_tokens,
+                output_tokens=stats.output_tokens,
+                cache_creation_tokens=stats.cache_creation_tokens,
+                cache_read_tokens=stats.cache_read_tokens,
+                estimated_cost_usd=round(cost_estimate, 4),
+                last_stats_update=now.isoformat(),
+            )
+        except Exception as e:
+            # Don't fail the loop if stats sync fails
+            self.log.warn(f"Failed to sync stats for {session.name}: {e}")
+
+    def is_daemon_claude_running(self) -> bool:
+        """Check if daemon claude is still running"""
+        if self.daemon_claude_window is None:
+            return False
+
+        # Check if our tracked window still exists
+        return self.tmux.window_exists(self.daemon_claude_window)
+
+    def is_daemon_claude_done(self) -> bool:
+        """Check if daemon claude has finished its task (at empty prompt or gone).
+
+        Returns True if:
+        - Window doesn't exist (closed/crashed)
+        - Window shows empty prompt AND no active work indicators
+        """
+        if not self.is_daemon_claude_running():
+            return True
+
+        # Capture pane content to check status
+        try:
+            result = subprocess.run(
+                [
+                    "tmux", "capture-pane",
+                    "-t", f"{self.tmux_session}:{self.daemon_claude_window}",
+                    "-p",
+                    "-S", "-30",  # Last 30 lines for better context
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+
+            if result.returncode != 0:
+                return True  # Can't capture = assume done
+
+            content = result.stdout
+
+            # If Claude is actively working, NOT done
+            # These indicators show Claude is thinking or running tools
+            active_indicators = [
+                '· ',           # Thinking indicator (· Thinking…, · Combobulating…)
+                'Running…',     # Tool is running
+                '(esc to interrupt',  # Active work message
+                '✽',            # Another thinking indicator
+            ]
+            for indicator in active_indicators:
+                if indicator in content:
+                    return False  # Still working
+
+            # Also check for tool calls that just started (no result yet)
+            # Pattern: ⏺ ToolName(...) without ⎿ result after
+            lines = content.split('\n')
+            for i, line in enumerate(lines):
+                if '⏺' in line and '(' in line:
+                    # Found a tool call - check if there's a result after it
+                    remaining = '\n'.join(lines[i+1:])
+                    if '⎿' not in remaining:
+                        return False  # Tool call without result = still working
+
+            # Check for empty prompt in last few lines
+            last_lines = [l.strip() for l in lines[-8:] if l.strip()]
+            for line in last_lines:
+                # Empty Claude Code prompt (just > or › with nothing after)
+                if line == '>' or line == '›':
+                    return True
+
+            return False
+
+        except subprocess.TimeoutExpired:
+            # Timeout checking status != daemon claude is done
+            # Return False to keep waiting - it may still be working
+            return False
+        except subprocess.SubprocessError:
+            # Other subprocess errors - can't determine status
+            # Return False to be safe (keep waiting rather than kill)
+            return False
+
+    def wait_for_daemon_claude(self, timeout: int = 300, poll_interval: int = 5) -> bool:
+        """Wait for daemon claude to complete its task.
+
+        Args:
+            timeout: Max seconds to wait (default 5 minutes)
+            poll_interval: Seconds between checks (default 5s)
+
+        Returns:
+            True if daemon claude completed, False if timed out
+        """
+        if not self.is_daemon_claude_running():
+            return True
+
+        self.log.info(f"Waiting for daemon claude to complete (timeout {timeout}s)...")
+        start_time = time.time()
+        has_seen_activity = False
+
+        while time.time() - start_time < timeout:
+            # Capture and log output while waiting
+            self.capture_daemon_claude_output()
+
+            # Check if daemon claude has started working (shows tool use indicator)
+            if not has_seen_activity:
+                has_seen_activity = self._has_daemon_claude_started()
+                if has_seen_activity:
+                    self.log.info("Daemon claude started working...")
+
+            # Only check for completion after we've seen activity
+            if has_seen_activity and self.is_daemon_claude_done():
+                elapsed = int(time.time() - start_time)
+                self.log.success(f"Daemon claude completed in {elapsed}s")
+                return True
+
+            time.sleep(poll_interval)
+
+        self.log.warn(f"Daemon claude timed out after {timeout}s")
+        return False
+
+    def _has_daemon_claude_started(self) -> bool:
+        """Check if daemon claude has started working (shows activity indicators)."""
+        if not self.is_daemon_claude_running():
+            return False
+
+        try:
+            result = subprocess.run(
+                [
+                    "tmux", "capture-pane",
+                    "-t", f"{self.tmux_session}:{self.daemon_claude_window}",
+                    "-p",
+                    "-S", "-30",
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+
+            if result.returncode != 0:
+                return False
+
+            content = result.stdout
+
+            # Look for signs Claude has started working:
+            # - Tool use indicator (⏺)
+            # - Thinking/processing
+            # - Any substantial output beyond just the prompt
+            activity_indicators = ['⏺', 'Read(', 'Write(', 'Edit(', 'Bash(', 'Grep(', 'Glob(']
+            for indicator in activity_indicators:
+                if indicator in content:
+                    return True
+
+            return False
+
+        except subprocess.SubprocessError:
+            return False
+
+    def kill_daemon_claude(self) -> None:
+        """Kill daemon claude window if it exists"""
+        if self.daemon_claude_window is not None and self.tmux.window_exists(self.daemon_claude_window):
+            self.log.info(f"Killing daemon claude window {self.daemon_claude_window}")
+            self.tmux.kill_window(self.daemon_claude_window)
+        self.daemon_claude_window = None
+
+    def cleanup_stale_daemon_claudes(self) -> None:
+        """Clean up any orphaned daemon claude windows.
+
+        This handles:
+        1. Our tracked daemon claude window that no longer exists
+        2. Orphaned windows with the daemon claude name from previous daemon runs
+        """
+        # Clear our reference if the window is gone
+        if self.daemon_claude_window is not None and not self.tmux.window_exists(self.daemon_claude_window):
+            self.log.info(f"Daemon claude window {self.daemon_claude_window} no longer exists")
+            self.daemon_claude_window = None
+
+        # Also kill any orphaned daemon claude windows (from previous daemon runs)
+        windows = self.tmux.list_windows()
+        for window in windows:
+            if window['name'] == self.DAEMON_CLAUDE_WINDOW_NAME:
+                window_idx = int(window['index'])
+                # If we're not tracking this window, it's orphaned
+                if self.daemon_claude_window != window_idx:
+                    self.log.info(f"Killing orphaned daemon claude window {window_idx}")
+                    self.tmux.kill_window(window_idx)
+
+    def capture_daemon_claude_output(self) -> None:
+        """Capture and log output from daemon claude window."""
+        if not self.is_daemon_claude_running():
+            return
+
+        try:
+            # Capture the pane content
+            result = subprocess.run(
+                [
+                    "tmux", "capture-pane",
+                    "-t", f"{self.tmux_session}:{self.daemon_claude_window}",
+                    "-p",  # Print to stdout
+                    "-S", "-50",  # Start from 50 lines before current position
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+
+            if result.returncode == 0:
+                lines = [line for line in result.stdout.split('\n') if line.strip()]
+                if lines:
+                    self.log.daemon_claude_output(lines)
+
+        except subprocess.SubprocessError:
+            pass  # Silently ignore capture errors
+
+    def count_interventions_from_log(self, sessions: list) -> Dict[str, int]:
+        """Count interventions per session from supervisor log since daemon claude launch.
+
+        Parses ~/.overcode/supervisor.log for entries after daemon_claude_launch_time
+        and counts actual interventions (not "No intervention needed" entries).
+
+        Args:
+            sessions: List of sessions to check for
+
+        Returns:
+            Dict mapping session name to intervention count
+        """
+        if not self.daemon_claude_launch_time:
+            return {}
+
+        log_path = Path.home() / ".overcode" / "supervisor.log"
+        if not log_path.exists():
+            return {}
+
+        counts: Dict[str, int] = {}
+        session_names = {s.name for s in sessions}
+
+        # Phrases that indicate an action WAS taken
+        action_phrases = [
+            "approved",
+            "rejected",
+            "sent ",  # "sent /exit", "sent feedback"
+            "provided",
+            "unblocked",
+        ]
+
+        # Phrases that indicate NO action was taken (overrides action phrases)
+        no_action_phrases = [
+            "no intervention needed",
+            "no action needed",
+        ]
+
+        try:
+            with open(log_path, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+
+                    # Parse timestamp - format: "Fri  2 Jan 2026 07:11:36 GMT: ..."
+                    # Also handles "Fri  2 Jan..." (double space)
+                    try:
+                        if ": " not in line:
+                            continue
+                        timestamp_part = line.split(": ")[0]
+                        # Try both single and double space after weekday
+                        entry_time = None
+                        for fmt in ["%a %d %b %Y %H:%M:%S %Z", "%a  %d %b %Y %H:%M:%S %Z"]:
+                            try:
+                                entry_time = datetime.strptime(timestamp_part.strip(), fmt)
+                                break
+                            except ValueError:
+                                continue
+                        if entry_time is None:
+                            continue
+                    except (ValueError, IndexError):
+                        continue
+
+                    # Skip entries before daemon claude launch
+                    if entry_time < self.daemon_claude_launch_time:
+                        continue
+
+                    # Check if this entry is about one of our sessions
+                    for name in session_names:
+                        if f"{name} - " in line:
+                            line_lower = line.lower()
+                            # First check if explicitly says "no action"
+                            if any(phrase in line_lower for phrase in no_action_phrases):
+                                break
+                            # Then check if an action was taken
+                            if any(phrase in line_lower for phrase in action_phrases):
+                                counts[name] = counts.get(name, 0) + 1
+                            break
+
+        except IOError:
+            pass
+
+        return counts
+
+    def update_intervention_counts(self, sessions: list) -> None:
+        """Update steers_count for sessions based on supervisor log interventions.
+
+        Called after daemon claude completes to track actual interventions.
+        """
+        counts = self.count_interventions_from_log(sessions)
+        if not counts:
+            return
+
+        for session in sessions:
+            if session.name in counts:
+                intervention_count = counts[session.name]
+                current_stats = session.stats
+                self.session_manager.update_stats(
+                    session.id,
+                    steers_count=current_stats.steers_count + intervention_count,
+                )
+                self.log.info(f"[{session.name}] +{intervention_count} daemon interventions")
+
+    def get_non_green_sessions(self) -> list:
+        """Get all sessions that are not in running state"""
+        sessions = self.session_manager.list_sessions()
+        non_green = []
+
+        for session in sessions:
+            # Skip the daemon claude itself (shouldn't appear, but just in case)
+            if session.name == 'daemon_claude':
+                continue
+
+            status, _, _ = self.status_detector.detect_status(session)
+            if status != STATUS_RUNNING:
+                non_green.append((session, status))
+
+        return non_green
+
+    def build_daemon_claude_context(self, non_green_sessions: list) -> str:
+        """Build initial context for daemon claude"""
+        context_parts = []
+
+        context_parts.append("You are the Overcode daemon claude agent.")
+        context_parts.append("Your mission: Make all RED/YELLOW/ORANGE sessions GREEN.")
+        context_parts.append("")
+        context_parts.append(f"TMUX SESSION: {self.tmux_session}")
+        context_parts.append(f"Sessions needing attention: {len(non_green_sessions)}")
+        context_parts.append("")
+
+        for session, status in non_green_sessions:
+            emoji = get_status_emoji(status)
+            context_parts.append(f"{emoji} {session.name} (window {session.tmux_window})")
+            if session.standing_instructions:
+                context_parts.append(f"   Autopilot: {session.standing_instructions}")
+            else:
+                context_parts.append(f"   No autopilot instructions set")
+            context_parts.append(f"   Working dir: {session.start_directory or 'unknown'}")
+            context_parts.append("")
+
+        context_parts.append("Read the daemon claude skill for how to control sessions via tmux.")
+        context_parts.append("Start by reading ~/.overcode/sessions/sessions.json to see full state.")
+        context_parts.append("Then check each non-green session and help them make progress.")
+
+        return "\n".join(context_parts)
+
+    def launch_daemon_claude(self, non_green_sessions: list):
+        """Launch daemon claude to handle non-green sessions.
+
+        This creates a non-interactive daemon claude directly in a tmux window
+        WITHOUT registering it in sessions.json. It's a background worker, not a
+        user-facing agent.
+        """
+        # Build context message
+        context = self.build_daemon_claude_context(non_green_sessions)
+
+        # Get the daemon claude skill path
+        skill_path = Path(__file__).parent / "daemon_claude_skill.md"
+
+        # Read the daemon claude skill content
+        with open(skill_path) as f:
+            skill_content = f.read()
+
+        # Build full prompt with skill + context
+        full_prompt = f"{skill_content}\n\n---\n\n{context}"
+
+        # Ensure tmux session exists
+        if not self.tmux.ensure_session():
+            self.log.error(f"Failed to create tmux session '{self.tmux.session_name}'")
+            return
+
+        # Create window for daemon claude (uses special name prefix)
+        window_index = self.tmux.create_window(
+            self.DAEMON_CLAUDE_WINDOW_NAME,
+            str(Path.home() / '.overcode')
+        )
+        if window_index is None:
+            self.log.error("Failed to create daemon claude window")
+            return
+
+        self.daemon_claude_window = window_index
+        self.daemon_claude_launch_time = datetime.now()
+
+        # Start Claude with auto-permissions
+        # Use dangerously-skip-permissions so daemon claude can run tmux commands
+        # without prompting. This is safe because daemon claude only operates on
+        # the agent sessions within the monitored tmux session.
+        claude_cmd = "claude code --dangerously-skip-permissions"
+        if not self.tmux.send_keys(window_index, claude_cmd, enter=True):
+            self.log.error("Failed to start Claude in daemon claude window")
+            return
+
+        # Wait for Claude to start up
+        time.sleep(3.0)
+
+        # Send the prompt via tmux load-buffer/paste-buffer for large text
+        self._send_prompt_to_window(window_index, full_prompt)
+
+    def _send_prompt_to_window(self, window_index: int, prompt: str) -> bool:
+        """Send a large prompt to a tmux window via load-buffer/paste-buffer."""
+        import os
+
+        lines = prompt.split('\n')
+        batch_size = 10
+
+        for i in range(0, len(lines), batch_size):
+            batch = lines[i:i + batch_size]
+            text = '\n'.join(batch)
+            if i + batch_size < len(lines):
+                text += '\n'  # Add newline between batches
+
+            try:
+                with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
+                    temp_path = f.name
+                    f.write(text)
+
+                subprocess.run(['tmux', 'load-buffer', temp_path], timeout=5, check=True)
+                subprocess.run([
+                    'tmux', 'paste-buffer', '-t',
+                    f"{self.tmux.session_name}:{window_index}"
+                ], timeout=5, check=True)
+            except subprocess.SubprocessError as e:
+                self.log.error(f"Failed to send prompt batch: {e}")
+                return False
+            finally:
+                try:
+                    os.unlink(temp_path)
+                except OSError:
+                    pass
+
+            time.sleep(0.1)
+
+        # Send Enter to submit the prompt
+        subprocess.run([
+            'tmux', 'send-keys', '-t',
+            f"{self.tmux.session_name}:{window_index}",
+            '', 'Enter'
+        ])
+
+        return True
+
+    def _interruptible_sleep(self, total_seconds: int) -> None:
+        """Sleep for total_seconds, but check for activity signal every 10s.
+
+        This allows the daemon to wake up quickly when the user becomes active,
+        even if we're in a long sleep interval (e.g., 1 hour idle).
+        """
+        chunk_size = 10  # Check every 10 seconds
+        elapsed = 0
+
+        while elapsed < total_seconds:
+            remaining = total_seconds - elapsed
+            sleep_time = min(chunk_size, remaining)
+            time.sleep(sleep_time)
+            elapsed += sleep_time
+
+            # Check for activity signal
+            if check_activity_signal():
+                self.log.info("User activity detected → waking up")
+                self.state.current_interval = INTERVAL_FAST
+                self.state.last_activity = datetime.now()
+                self.state.save()
+                return  # Exit sleep early
+
+    def is_controller_active(self) -> bool:
+        """Check if user is actively using the controller (by monitoring output changes)"""
+        try:
+            # Check the overcode-controller session's bottom pane
+            result = subprocess.run(
+                ["tmux", "capture-pane", "-t", "overcode-controller:0.1", "-p"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode != 0:
+                return False
+
+            # Count non-empty lines
+            lines = [l for l in result.stdout.split('\n') if l.strip()]
+            current_count = len(lines)
+
+            # Compare with last check
+            now = datetime.now()
+            if self.last_controller_check:
+                time_since_check = (now - self.last_controller_check).total_seconds()
+                # If output changed recently, user is active
+                if current_count != self.controller_line_count and time_since_check < 60:
+                    self.state.last_activity = now
+                    self.controller_line_count = current_count
+                    self.last_controller_check = now
+                    return True
+
+            self.controller_line_count = current_count
+            self.last_controller_check = now
+
+            # Also consider "recently active" if activity was in last 2 minutes
+            if self.state.last_activity:
+                since_activity = (now - self.state.last_activity).total_seconds()
+                if since_activity < 120:
+                    return True
+
+            return False
+        except subprocess.SubprocessError:
+            # tmux command failed (timeout, not found, etc.) - assume not active
+            return False
+        except (OSError, IOError) as e:
+            # File/process errors - log and assume not active
+            self.log.warn(f"Error checking controller activity: {e}")
+            return False
+
+    def calculate_interval(self, sessions: list, non_green: list, all_waiting_user: bool) -> int:
+        """Calculate appropriate loop interval based on current state"""
+        # If user is active, stay fast
+        if self.is_controller_active():
+            return INTERVAL_FAST
+
+        # No sessions at all - go idle
+        if not sessions:
+            return INTERVAL_IDLE
+
+        # All sessions waiting for user - slow down
+        if all_waiting_user and not self.is_daemon_claude_running():
+            return INTERVAL_SLOW
+
+        # Agents are working or daemon claude is active - stay fast
+        return INTERVAL_FAST
+
+    def run(self, check_interval: int = 10):
+        """Main daemon loop with adaptive speed"""
+        # Check if another daemon is already running (via PID file)
+        existing_pid = get_daemon_pid()
+        if existing_pid is not None and existing_pid != os.getpid():
+            self.log.error(f"Another daemon is already running (PID {existing_pid})")
+            self.log.info(f"Kill it with: kill {existing_pid}")
+            sys.exit(1)
+
+        # Also check for orphaned daemon processes (not tracked in PID file)
+        try:
+            result = subprocess.run(
+                ["pgrep", "-f", "overcode.*daemon|overcode\\.daemon"],
+                capture_output=True, text=True, timeout=5
+            )
+            if result.returncode == 0:
+                other_pids = [int(p) for p in result.stdout.strip().split('\n') if p]
+                other_pids = [p for p in other_pids if p != os.getpid()]
+                if other_pids:
+                    self.log.warn(f"Found orphaned daemon process(es): {other_pids}")
+                    self.log.info(f"Kill them with: kill {' '.join(map(str, other_pids))}")
+                    # Don't exit - just warn. Let user decide to kill orphans.
+        except (subprocess.SubprocessError, ValueError):
+            pass  # pgrep failed, proceed anyway
+
+        # Write PID file for process detection
+        _write_pid_file()
+        self.log.section("Overcode Daemon")
+        self.log.info(f"PID: {os.getpid()}")
+        self.log.info(f"Mode: {self.state.mode}")
+        self.log.info(f"Monitoring tmux session: {self.tmux_session}")
+        self.log.info(f"Base interval: {check_interval}s (adaptive)")
+
+        self.state.started_at = datetime.now()
+        self.state.current_interval = check_interval
+        self.state.status = "active"
+        self.state.save()
+
+        try:
+            while True:
+                self.state.loop_count += 1
+                self.state.last_loop_time = datetime.now()
+
+                # Check for user activity signal from TUI
+                if check_activity_signal():
+                    if self.state.current_interval != INTERVAL_FAST:
+                        self.log.info("User activity detected → fast interval")
+                        self.state.current_interval = INTERVAL_FAST
+                    self.state.last_activity = datetime.now()
+
+                # Cleanup any orphaned daemon claude windows from previous daemon runs
+                self.cleanup_stale_daemon_claudes()
+
+                # Get all sessions and their statuses
+                sessions = self.session_manager.list_sessions()
+                non_green = self.get_non_green_sessions()
+
+                # Log loop status with pretty formatting
+                green_count = len(sessions) - len(non_green)
+                self.log.status_summary(
+                    total=len(sessions),
+                    green=green_count,
+                    non_green=len(non_green),
+                    loop=self.state.loop_count
+                )
+
+                # Log each agent's individual status and track stats
+                for session in sessions:
+                    status, activity, _ = self.status_detector.detect_status(session)
+                    self.log.agent_status(session.name, status, activity)
+                    # Track state transitions and update interaction stats
+                    self.track_session_stats(session, status)
+                    # Also log to history file for timeline visualization
+                    log_agent_status(session.name, status, activity)
+
+                # Sync Claude Code stats periodically (every 6 loops = ~1 minute at fast interval)
+                if self.state.loop_count % 6 == 0:
+                    for session in sessions:
+                        self.sync_claude_code_stats(session)
+
+                # Check if ALL non-green sessions are waiting for user
+                all_waiting_user = (
+                    non_green and
+                    all(status == STATUS_WAITING_USER for _, status in non_green)
+                )
+
+                # Check if any session has standing instructions (daemon claude can help)
+                any_has_instructions = any(
+                    session.standing_instructions
+                    for session, _ in non_green
+                )
+
+                if non_green:
+                    # Skip daemon claude only if ALL waiting_user AND none have instructions
+                    if all_waiting_user and not any_has_instructions:
+                        self.state.status = "waiting"
+                        self.log.warn("All sessions waiting for user input (no instructions set)")
+                    elif self.state.mode == MODE_MONITOR:
+                        # Monitor mode: track stats but never launch daemon claude
+                        self.state.status = "monitoring"
+                    else:
+                        # Supervise mode: Launch daemon claude if not already running
+                        if not self.is_daemon_claude_running():
+                            reason = "with instructions" if any_has_instructions else "non-user-blocked"
+                            self.log.info(f"Launching daemon claude for {len(non_green)} session(s) ({reason})...")
+                            self.launch_daemon_claude(non_green)
+                            self.state.daemon_claude_launches += 1
+                            self.state.status = "supervising"
+                            self.log.success(f"Daemon claude launched in window {self.daemon_claude_window}")
+
+                        # Wait for daemon claude to complete its task
+                        if self.is_daemon_claude_running():
+                            completed = self.wait_for_daemon_claude(timeout=300)
+
+                            # Capture final output
+                            self.capture_daemon_claude_output()
+
+                            if completed:
+                                # Only kill on successful completion
+                                self.kill_daemon_claude()
+
+                                # Update intervention counts from supervisor log
+                                sessions_handled = [session for session, _ in non_green]
+                                self.update_intervention_counts(sessions_handled)
+                            else:
+                                # Timeout - let daemon claude keep working
+                                # Don't kill it, just log and continue to next loop
+                                self.log.warn("Daemon claude still working after 5 min, continuing...")
+                else:
+                    if sessions:
+                        self.state.status = "idle"
+                        self.log.success("All sessions GREEN")
+                    else:
+                        self.state.status = "no_agents"
+
+                # Calculate next interval
+                new_interval = self.calculate_interval(sessions, non_green, all_waiting_user)
+                if new_interval != self.state.current_interval:
+                    interval_names = {
+                        INTERVAL_FAST: "fast (10s)",
+                        INTERVAL_SLOW: "slow (5m)",
+                        INTERVAL_IDLE: "idle (1h)"
+                    }
+                    self.log.info(f"Loop speed → {interval_names.get(new_interval, f'{new_interval}s')}")
+                    self.state.current_interval = new_interval
+
+                # Save state for TUI
+                self.state.save()
+
+                # Sleep in chunks, checking for activity signal periodically
+                self._interruptible_sleep(self.state.current_interval)
+
+        except KeyboardInterrupt:
+            self.log.section("Shutting Down")
+            self.state.status = "stopped"
+            self.state.save()
+            _remove_pid_file()
+            self.log.info("Daemon stopped")
+            sys.exit(0)
+        finally:
+            # Ensure PID file is removed even on unexpected exit
+            _remove_pid_file()
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Overcode daemon")
+    parser.add_argument(
+        "--session",
+        default="agents",
+        help="Tmux session to monitor (default: agents)"
+    )
+    parser.add_argument(
+        "--interval",
+        type=int,
+        default=10,
+        help="Check interval in seconds (default: 10)"
+    )
+
+    args = parser.parse_args()
+
+    daemon = Daemon(args.session)
+    daemon.run(args.interval)
+
+
+if __name__ == "__main__":
+    main()