overcode 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

overcode/pid_utils.py

@@ -150,23 +150,30 @@ def acquire_daemon_lock(pid_file: Path) -> Tuple[bool, Optional[int]]:
         return False, None
 
 
-def count_daemon_processes(pattern: str = "monitor_daemon") -> int:
+def count_daemon_processes(pattern: str = "monitor_daemon", session: str = None) -> int:
     """Count running daemon processes matching the pattern.
 
     Uses pgrep to find processes matching the pattern.
 
     Args:
         pattern: Pattern to search for in process names/args
+        session: If provided, only count daemons for this specific session
 
     Returns:
-        Number of matching processes (excluding this check process)
+        Number of matching processes
     """
     import subprocess
 
+    # Build pattern - if session provided, make it session-specific
+    if session:
+        search_pattern = f"{pattern} --session {session}"
+    else:
+        search_pattern = pattern
+
     try:
         # Use pgrep to find matching processes
         result = subprocess.run(
-            ["pgrep", "-f", pattern],
+            ["pgrep", "-f", search_pattern],
             capture_output=True,
             text=True,
             timeout=5.0,

overcode/protocols.py

@@ -78,6 +78,18 @@ class TmuxInterface(Protocol):
         """Attach to a tmux session (replaces current process)."""
         ...
 
+    def select_window(self, session: str, window: int) -> bool:
+        """Select a window in a tmux session.
+
+        Args:
+            session: tmux session name
+            window: window number to select
+
+        Returns:
+            True if successful, False otherwise
+        """
+        ...
+
 
 @runtime_checkable
 class FileSystemInterface(Protocol):

overcode/session_manager.py

@@ -88,6 +88,9 @@ class Session:
     # Statistics
     stats: SessionStats = field(default_factory=SessionStats)
 
+    # Sleep mode - agent is paused and excluded from stats
+    is_asleep: bool = False
+
     def to_dict(self) -> dict:
         data = asdict(self)
         # Convert stats to dict

overcode/settings.py

@@ -8,6 +8,8 @@ Configuration hierarchy:
 1. Environment variables (highest priority)
 2. Config file (~/.overcode/config.yaml)
 3. Default values (lowest priority)
+
+TODO: Make INTERVAL_FAST/SLOW/IDLE configurable via config.yaml
 """
 
 import os
@@ -19,7 +21,7 @@ import os
 DAEMON_VERSION = 2  # Increment when daemon behavior changes
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Set
 
 import yaml
 
@@ -328,6 +330,16 @@ def get_supervisor_log_path(session: str) -> Path:
     return get_session_dir(session) / "supervisor.log"
 
 
+def get_web_server_pid_path(session: str) -> Path:
+    """Get web server PID file path for a specific session."""
+    return get_session_dir(session) / "web_server.pid"
+
+
+def get_web_server_port_path(session: str) -> Path:
+    """Get web server port file path for a specific session."""
+    return get_session_dir(session) / "web_server.port"
+
+
 def ensure_session_dir(session: str) -> Path:
     """Ensure session directory exists and return it."""
     session_dir = get_session_dir(session)
@@ -367,6 +379,9 @@ class TUIPreferences:
     timeline_visible: bool = True
     daemon_panel_visible: bool = False
     view_mode: str = "tree"  # tree, list_preview
+    tmux_sync: bool = False  # sync navigation to external tmux pane
+    # Session IDs of stalled agents that have been visited by the user
+    visited_stalled_agents: Set[str] = field(default_factory=set)
 
     @classmethod
     def load(cls, session: str) -> "TUIPreferences":
@@ -389,6 +404,8 @@ class TUIPreferences:
                     timeline_visible=data.get("timeline_visible", True),
                     daemon_panel_visible=data.get("daemon_panel_visible", False),
                     view_mode=data.get("view_mode", "tree"),
+                    tmux_sync=data.get("tmux_sync", False),
+                    visited_stalled_agents=set(data.get("visited_stalled_agents", [])),
                 )
         except (json.JSONDecodeError, IOError):
             return cls()
@@ -407,6 +424,8 @@ class TUIPreferences:
                     "timeline_visible": self.timeline_visible,
                     "daemon_panel_visible": self.daemon_panel_visible,
                     "view_mode": self.view_mode,
+                    "tmux_sync": self.tmux_sync,
+                    "visited_stalled_agents": list(self.visited_stalled_agents),
                 }, f, indent=2)
         except (IOError, OSError):
             pass  # Best effort

overcode/standing_instructions.py

@@ -24,8 +24,17 @@ class InstructionPreset:
 
 # Default presets - used to generate initial presets.json
 DEFAULT_PRESETS: Dict[str, InstructionPreset] = {
-    "DEFAULT": InstructionPreset(
-        name="DEFAULT",
+    "DO_NOTHING": InstructionPreset(
+        name="DO_NOTHING",
+        description="Supervisor ignores this agent (default)",
+        instructions=(
+            "Do not interact with this agent at all. Do not approve or reject any prompts. "
+            "Do not send any input. Leave the agent completely alone and let it wait for "
+            "the human user. This agent is not under supervisor control."
+        ),
+    ),
+    "STANDARD": InstructionPreset(
+        name="STANDARD",
         description="General-purpose safe automation",
         instructions=(
             "Approve safe operations within the working directory: file reads/writes/edits, "
@@ -208,11 +217,11 @@ def get_preset_names() -> List[str]:
         List of preset names
     """
     presets = load_presets()
-    # Return in a consistent order (DEFAULT first, then alphabetical)
+    # Return in a consistent order (DO_NOTHING first, then alphabetical)
     names = list(presets.keys())
-    if "DEFAULT" in names:
-        names.remove("DEFAULT")
-        names = ["DEFAULT"] + sorted(names)
+    if "DO_NOTHING" in names:
+        names.remove("DO_NOTHING")
+        names = ["DO_NOTHING"] + sorted(names)
     else:
         names = sorted(names)
     return names

overcode/status_constants.py

@@ -17,6 +17,7 @@ STATUS_NO_INSTRUCTIONS = "no_instructions"
 STATUS_WAITING_SUPERVISOR = "waiting_supervisor"
 STATUS_WAITING_USER = "waiting_user"
 STATUS_TERMINATED = "terminated"  # Claude Code exited, shell prompt showing
+STATUS_ASLEEP = "asleep"  # Human marked agent as paused/snoozed (excluded from stats)
 
 # All valid agent status values
 ALL_STATUSES = [
@@ -25,6 +26,7 @@ ALL_STATUSES = [
     STATUS_WAITING_SUPERVISOR,
     STATUS_WAITING_USER,
     STATUS_TERMINATED,
+    STATUS_ASLEEP,
 ]
 
 
@@ -60,6 +62,7 @@ STATUS_EMOJIS = {
     STATUS_WAITING_SUPERVISOR: "🟠",
     STATUS_WAITING_USER: "🔴",
     STATUS_TERMINATED: "⚫",  # Black circle - Claude exited
+    STATUS_ASLEEP: "💤",  # Sleeping/snoozed - human marked as paused
 }
 
 
@@ -78,6 +81,7 @@ STATUS_COLORS = {
     STATUS_WAITING_SUPERVISOR: "orange1",
     STATUS_WAITING_USER: "red",
     STATUS_TERMINATED: "dim",  # Grey for terminated
+    STATUS_ASLEEP: "dim",  # Grey for sleeping
 }
 
 
@@ -96,6 +100,7 @@ STATUS_SYMBOLS = {
     STATUS_WAITING_SUPERVISOR: ("🟠", "orange1"),
     STATUS_WAITING_USER: ("🔴", "red"),
     STATUS_TERMINATED: ("⚫", "dim"),
+    STATUS_ASLEEP: ("💤", "dim"),  # Sleeping/snoozed
 }
 
 
@@ -114,6 +119,7 @@ AGENT_TIMELINE_CHARS = {
     STATUS_WAITING_SUPERVISOR: "▒",
     STATUS_WAITING_USER: "░",
     STATUS_TERMINATED: "×",  # Small X - terminated
+    STATUS_ASLEEP: "z",  # Lowercase z for sleeping
 }
 
 
@@ -188,3 +194,8 @@ def is_waiting_status(status: str) -> bool:
 def is_user_blocked(status: str) -> bool:
     """Check if status indicates user intervention is required."""
     return status == STATUS_WAITING_USER
+
+
+def is_asleep(status: str) -> bool:
+    """Check if status indicates agent is asleep (paused by human)."""
+    return status == STATUS_ASLEEP

overcode/status_detector.py

@@ -116,6 +116,13 @@ class StatusDetector:
 
         last_line = last_lines[-1]
 
+        # Check for spawn failure FIRST (command not found, etc.)
+        # This should be detected before shell prompt check because the error
+        # message appears before the shell prompt returns
+        spawn_error = self._detect_spawn_failure(lines)
+        if spawn_error:
+            return self.STATUS_WAITING_USER, spawn_error, content
+
         # Check for shell prompt (Claude Code has terminated)
         # Shell prompts typically end with $ or % and have username@hostname pattern
         # Also check for absence of Claude Code UI elements
@@ -297,6 +304,37 @@ class StatusDetector:
         ]
         return '\n'.join(filtered)
 
+    def _detect_spawn_failure(self, lines: list) -> str | None:
+        """Detect if the claude command failed to spawn.
+
+        Checks for common error messages like "command not found" that indicate
+        the claude CLI is not installed or not in PATH.
+
+        Args:
+            lines: All lines from the pane content
+
+        Returns:
+            Error message string if spawn failure detected, None otherwise
+        """
+        # Check recent lines for spawn failure patterns
+        # We check the last 20 lines to catch the error message
+        recent_lines = lines[-20:] if len(lines) > 20 else lines
+        recent_text = ' '.join(recent_lines).lower()
+
+        if matches_any(recent_text, self.patterns.spawn_failure_patterns):
+            # Find the specific error line for a better message
+            for line in reversed(recent_lines):
+                line_lower = line.lower()
+                if any(p.lower() in line_lower for p in self.patterns.spawn_failure_patterns):
+                    # Extract just the error part, clean it up
+                    error_msg = line.strip()
+                    if len(error_msg) > 80:
+                        error_msg = error_msg[:77] + "..."
+                    return f"Spawn failed: {error_msg}"
+            return "Spawn failed: claude command not found - is Claude CLI installed?"
+
+        return None
+
     def _is_shell_prompt(self, lines: list) -> bool:
         """Detect if we're at a shell prompt (Claude Code has exited).
 

overcode/status_patterns.py

@@ -115,6 +115,18 @@ class StatusPatterns:
     # Format: "  /command-name     Description text"
     command_menu_pattern: str = r"^\s*/[\w-]+\s{2,}\S"
 
+    # Spawn failure patterns - when the claude command fails to start
+    # These indicate the command was not found or failed to execute
+    # Checked against pane content to detect failed spawns
+    spawn_failure_patterns: List[str] = field(default_factory=lambda: [
+        "command not found",
+        "not found:",  # zsh style: "zsh: command not found: claude"
+        "no such file or directory",
+        "permission denied",
+        "cannot execute",
+        "is not recognized",  # Windows-style (for future compatibility)
+    ])
+
 
 # Default patterns instance
 DEFAULT_PATTERNS = StatusPatterns()

overcode/supervisor_daemon.py

@@ -15,10 +15,15 @@ Prerequisites:
 
 Architecture:
     Monitor Daemon (metrics) → monitor_daemon_state.json → Supervisor Daemon (claude)
+
+TODO: Add unit tests (currently 0% coverage)
+TODO: Extract _send_prompt_to_window to a shared tmux utilities module
+(duplicated in launcher.py)
 """
 
 import json
 import os
+import signal
 import subprocess
 import sys
 import tempfile
@@ -28,20 +33,16 @@ from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Optional
 
-from rich.console import Console
-from rich.text import Text
-from rich.theme import Theme
-
+from .daemon_logging import SupervisorDaemonLogger
+from .daemon_utils import create_daemon_helpers
 from .monitor_daemon_state import (
     MonitorDaemonState,
     SessionDaemonState,
     get_monitor_daemon_state,
 )
 from .pid_utils import (
-    get_process_pid,
-    is_process_running,
+    acquire_daemon_lock,
     remove_pid_file,
-    write_pid_file,
 )
 from .session_manager import SessionManager
 from .settings import (
@@ -131,105 +132,6 @@ class SupervisorStats:
             return cls()
 
 
-# Rich theme for supervisor logs
-SUPERVISOR_THEME = Theme({
-    "info": "cyan",
-    "warn": "yellow",
-    "error": "bold red",
-    "success": "bold green",
-    "daemon_claude": "magenta",
-    "dim": "dim white",
-    "highlight": "bold white",
-})
-
-
-class SupervisorLogger:
-    """Rich-based logger for supervisor daemon."""
-
-    def __init__(self, log_file: Path = None):
-        self.log_file = log_file or PATHS.supervisor_log
-        self.log_file.parent.mkdir(parents=True, exist_ok=True)
-        self.console = Console(theme=SUPERVISOR_THEME, force_terminal=True)
-        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."""
-        new_lines = []
-
-        for line in lines:
-            stripped = line.strip()
-            if not stripped:
-                continue
-            if stripped not in self._seen_daemon_claude_lines:
-                new_lines.append(stripped)
-                self._seen_daemon_claude_lines.add(stripped)
-
-        # Limit set size
-        if len(self._seen_daemon_claude_lines) > 500:
-            current_lines = {line.strip() for line in lines if line.strip()}
-            self._seen_daemon_claude_lines = current_lines
-
-        if new_lines:
-            for line in new_lines:
-                self._write_to_file(f"[DAEMON_CLAUDE] {line}", "INFO")
-                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)
-
-
 class SupervisorDaemon:
     """Background daemon that orchestrates daemon claude for non-green sessions.
 
@@ -244,7 +146,7 @@ class SupervisorDaemon:
         tmux_session: str = None,
         session_manager: SessionManager = None,
         tmux_manager: TmuxManager = None,
-        logger: SupervisorLogger = None,
+        logger: SupervisorDaemonLogger = None,
     ):
         """Initialize the supervisor daemon.
 
@@ -252,7 +154,7 @@ class SupervisorDaemon:
             tmux_session: Name of the tmux session to manage
             session_manager: Optional SessionManager for dependency injection
             tmux_manager: Optional TmuxManager for dependency injection
-            logger: Optional SupervisorLogger for dependency injection
+            logger: Optional SupervisorDaemonLogger for dependency injection
         """
         self.tmux_session = tmux_session or DAEMON.default_tmux_session
         self.session_manager = session_manager or SessionManager()
@@ -267,7 +169,7 @@ class SupervisorDaemon:
         self.log_path = get_supervisor_log_path(self.tmux_session)
 
         # Logger with session-specific log file
-        self.log = logger or SupervisorLogger(log_file=self.log_path)
+        self.log = logger or SupervisorDaemonLogger(log_file=self.log_path)
 
         # Load persistent supervisor stats
         self.supervisor_stats = SupervisorStats.load(self.stats_path)
@@ -808,20 +710,30 @@ class SupervisorDaemon:
         """
         check_interval = check_interval or DAEMON.interval_fast
 
-        # Check for existing supervisor daemon
-        existing_pid = get_process_pid(self.pid_path)
-        if existing_pid is not None and existing_pid != os.getpid():
-            self.log.error(f"Another supervisor daemon is running (PID {existing_pid})")
+        # Atomically check if already running and acquire lock
+        # This prevents TOCTOU race conditions that could cause multiple daemons
+        acquired, existing_pid = acquire_daemon_lock(self.pid_path)
+        if not acquired:
+            if existing_pid:
+                self.log.error(f"Supervisor daemon already running (PID {existing_pid})")
+            else:
+                self.log.error("Could not acquire daemon lock (another daemon may be starting)")
             sys.exit(1)
 
-        # Write PID file
-        write_pid_file(self.pid_path)
-
         self.log.section("Supervisor Daemon")
         self.log.info(f"PID: {os.getpid()}")
         self.log.info(f"Tmux session: {self.tmux_session}")
         self.log.info(f"Check interval: {check_interval}s")
 
+        # Setup signal handlers for graceful shutdown
+        def handle_shutdown(signum, frame):
+            self.log.info("Shutdown signal received")
+            self._shutdown = True
+
+        signal.signal(signal.SIGTERM, handle_shutdown)
+        signal.signal(signal.SIGINT, handle_shutdown)
+        self._shutdown = False
+
         # Wait for monitor daemon
         self.log.info("Waiting for Monitor Daemon...")
         if not self.wait_for_monitor_daemon():
@@ -834,7 +746,7 @@ class SupervisorDaemon:
         self.status = "active"
 
         try:
-            while True:
+            while not self._shutdown:
                 self.loop_count += 1
 
                 # Cleanup orphaned daemon claudes
@@ -914,64 +826,21 @@ class SupervisorDaemon:
 
                 time.sleep(check_interval)
 
-        except KeyboardInterrupt:
-            self.log.section("Shutting Down")
-            self.status = "stopped"
-            remove_pid_file(self.pid_path)
-            self.log.info("Supervisor daemon stopped")
-            sys.exit(0)
+        except Exception as e:
+            self.log.error(f"Supervisor daemon error: {e}")
+            raise
         finally:
+            self.log.info("Supervisor daemon shutting down")
+            self.status = "stopped"
             remove_pid_file(self.pid_path)
 
 
-def is_supervisor_daemon_running(session: str = None) -> bool:
-    """Check if the supervisor daemon is running for a session.
-
-    Args:
-        session: tmux session name (default: from config)
-    """
-    if session is None:
-        session = DAEMON.default_tmux_session
-    return is_process_running(get_supervisor_daemon_pid_path(session))
-
-
-def get_supervisor_daemon_pid(session: str = None) -> Optional[int]:
-    """Get the supervisor daemon PID if running.
-
-    Args:
-        session: tmux session name (default: from config)
-    """
-    if session is None:
-        session = DAEMON.default_tmux_session
-    return get_process_pid(get_supervisor_daemon_pid_path(session))
-
-
-def stop_supervisor_daemon(session: str = None) -> bool:
-    """Stop the supervisor daemon if running.
-
-    Args:
-        session: tmux session name (default: from config)
-
-    Returns:
-        True if daemon was stopped, False if it wasn't running.
-    """
-    import signal
-
-    if session is None:
-        session = DAEMON.default_tmux_session
-    pid_path = get_supervisor_daemon_pid_path(session)
-    pid = get_process_pid(pid_path)
-    if pid is None:
-        remove_pid_file(pid_path)
-        return False
-
-    try:
-        os.kill(pid, signal.SIGTERM)
-        remove_pid_file(pid_path)
-        return True
-    except (OSError, ProcessLookupError):
-        remove_pid_file(pid_path)
-        return False
+# Create PID helper functions using factory
+(
+    is_supervisor_daemon_running,
+    get_supervisor_daemon_pid,
+    stop_supervisor_daemon,
+) = create_daemon_helpers(get_supervisor_daemon_pid_path, "supervisor")
 
 
 def main():