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

overcode/monitor_daemon_core.py

@@ -0,0 +1,261 @@
+"""
+Pure business logic for Monitor Daemon.
+
+These functions contain no I/O and are fully unit-testable.
+They are used by MonitorDaemon but can be tested independently.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional, List, Tuple
+
+from .status_constants import STATUS_RUNNING, STATUS_TERMINATED, STATUS_ASLEEP
+
+
+@dataclass
+class TimeAccumulationResult:
+    """Result of time accumulation calculation."""
+    green_seconds: float
+    non_green_seconds: float
+    sleep_seconds: float  # Track sleep time separately (#141)
+    state_changed: bool
+    was_capped: bool  # True if time was capped to uptime
+
+
+def calculate_time_accumulation(
+    current_status: str,
+    previous_status: Optional[str],
+    elapsed_seconds: float,
+    current_green: float,
+    current_non_green: float,
+    current_sleep: float,
+    session_start: Optional[datetime],
+    now: datetime,
+    tolerance: float = 1.1,  # 10% tolerance for timing jitter
+) -> TimeAccumulationResult:
+    """Calculate accumulated green/non-green/sleep time based on current status.
+
+    Pure function - no side effects, fully testable.
+
+    Args:
+        current_status: Current agent status (running, waiting_user, etc.)
+        previous_status: Previous status (None if first observation)
+        elapsed_seconds: Seconds since last observation
+        current_green: Current accumulated green time
+        current_non_green: Current accumulated non-green time
+        current_sleep: Current accumulated sleep time (#141)
+        session_start: When the session started (for cap calculation)
+        now: Current time
+        tolerance: How much accumulated time can exceed uptime (1.1 = 10%)
+
+    Returns:
+        TimeAccumulationResult with updated times and metadata
+    """
+    if elapsed_seconds <= 0:
+        return TimeAccumulationResult(
+            green_seconds=current_green,
+            non_green_seconds=current_non_green,
+            sleep_seconds=current_sleep,
+            state_changed=False,
+            was_capped=False,
+        )
+
+    green = current_green
+    non_green = current_non_green
+    sleep = current_sleep
+
+    # Accumulate based on status
+    if current_status == STATUS_RUNNING:
+        green += elapsed_seconds
+    elif current_status == STATUS_ASLEEP:
+        sleep += elapsed_seconds  # Track sleep time separately (#141)
+    elif current_status != STATUS_TERMINATED:
+        non_green += elapsed_seconds
+    # else: terminated - don't accumulate time
+
+    # Cap accumulated time to session uptime
+    was_capped = False
+    if session_start is not None:
+        max_allowed = (now - session_start).total_seconds()
+        total_accumulated = green + non_green + sleep
+
+        if total_accumulated > max_allowed * tolerance:
+            # Scale down to sane values
+            ratio = max_allowed / total_accumulated if total_accumulated > 0 else 1.0
+            green = green * ratio
+            non_green = non_green * ratio
+            sleep = sleep * ratio
+            was_capped = True
+
+    state_changed = previous_status is not None and previous_status != current_status
+
+    return TimeAccumulationResult(
+        green_seconds=green,
+        non_green_seconds=non_green,
+        sleep_seconds=sleep,
+        state_changed=state_changed,
+        was_capped=was_capped,
+    )
+
+
+def calculate_cost_estimate(
+    input_tokens: int,
+    output_tokens: int,
+    cache_creation_tokens: int = 0,
+    cache_read_tokens: int = 0,
+    price_input: float = 15.0,
+    price_output: float = 75.0,
+    price_cache_write: float = 18.75,
+    price_cache_read: float = 1.50,
+) -> float:
+    """Calculate estimated cost from token counts.
+
+    Pure function - no side effects, fully testable.
+
+    Args:
+        input_tokens: Number of input tokens
+        output_tokens: Number of output tokens
+        cache_creation_tokens: Number of cache creation tokens
+        cache_read_tokens: Number of cache read tokens
+        price_input: Price per million input tokens (default: Opus 4.5)
+        price_output: Price per million output tokens (default: Opus 4.5)
+        price_cache_write: Price per million cache write tokens (default: Opus 4.5)
+        price_cache_read: Price per million cache read tokens (default: Opus 4.5)
+
+    Returns:
+        Estimated cost in USD
+    """
+    return (
+        (input_tokens / 1_000_000) * price_input +
+        (output_tokens / 1_000_000) * price_output +
+        (cache_creation_tokens / 1_000_000) * price_cache_write +
+        (cache_read_tokens / 1_000_000) * price_cache_read
+    )
+
+
+def calculate_total_tokens(
+    input_tokens: int,
+    output_tokens: int,
+    cache_creation_tokens: int = 0,
+    cache_read_tokens: int = 0,
+) -> int:
+    """Calculate total token count.
+
+    Pure function - no side effects, fully testable.
+    """
+    return input_tokens + output_tokens + cache_creation_tokens + cache_read_tokens
+
+
+def calculate_median(values: List[float]) -> float:
+    """Calculate median of a list of values.
+
+    Pure function - no side effects, fully testable.
+
+    Args:
+        values: List of numeric values
+
+    Returns:
+        Median value, or 0.0 if list is empty
+    """
+    if not values:
+        return 0.0
+    sorted_values = sorted(values)
+    n = len(sorted_values)
+    if n % 2 == 0:
+        return (sorted_values[n // 2 - 1] + sorted_values[n // 2]) / 2
+    return sorted_values[n // 2]
+
+
+def calculate_green_percentage(green_seconds: float, non_green_seconds: float) -> int:
+    """Calculate percentage of time spent in green (running) state.
+
+    Pure function - no side effects, fully testable.
+
+    Args:
+        green_seconds: Total green time
+        non_green_seconds: Total non-green time
+
+    Returns:
+        Integer percentage (0-100)
+    """
+    total = green_seconds + non_green_seconds
+    if total <= 0:
+        return 0
+    return int((green_seconds / total) * 100)
+
+
+def aggregate_session_stats(
+    sessions: List[dict],
+) -> Tuple[int, float, float, int]:
+    """Aggregate statistics across multiple sessions.
+
+    Pure function - no side effects, fully testable.
+
+    Args:
+        sessions: List of session dicts with 'status', 'green_time_seconds',
+                  'non_green_time_seconds', 'is_asleep' keys
+
+    Returns:
+        Tuple of (green_count, total_green_time, total_non_green_time, active_count)
+    """
+    green_count = 0
+    total_green = 0.0
+    total_non_green = 0.0
+    active_count = 0
+
+    for session in sessions:
+        # Skip asleep sessions
+        if session.get('is_asleep', False):
+            continue
+
+        active_count += 1
+        status = session.get('status', '')
+
+        if status == STATUS_RUNNING:
+            green_count += 1
+
+        total_green += session.get('green_time_seconds', 0.0)
+        total_non_green += session.get('non_green_time_seconds', 0.0)
+
+    return green_count, total_green, total_non_green, active_count
+
+
+def should_sync_stats(
+    last_sync: Optional[datetime],
+    now: datetime,
+    interval_seconds: float,
+) -> bool:
+    """Determine if stats should be synced based on interval.
+
+    Pure function - no side effects, fully testable.
+
+    Args:
+        last_sync: Time of last sync (None if never synced)
+        now: Current time
+        interval_seconds: Minimum seconds between syncs
+
+    Returns:
+        True if sync should occur
+    """
+    if last_sync is None:
+        return True
+    return (now - last_sync).total_seconds() >= interval_seconds
+
+
+def parse_datetime_safe(value: Optional[str]) -> Optional[datetime]:
+    """Safely parse an ISO datetime string.
+
+    Pure function - no side effects, fully testable.
+
+    Args:
+        value: ISO format datetime string, or None
+
+    Returns:
+        Parsed datetime, or None if parsing fails
+    """
+    if value is None:
+        return None
+    try:
+        return datetime.fromisoformat(value)
+    except (ValueError, TypeError):
+        return None

overcode/monitor_daemon_state.py

@@ -46,6 +46,7 @@ class SessionDaemonState:
     # Time tracking (authoritative - only Monitor Daemon updates these)
     green_time_seconds: float = 0.0
     non_green_time_seconds: float = 0.0
+    sleep_time_seconds: float = 0.0
 
     # Claude Code stats (synced from ~/.claude/projects/)
     interaction_count: int = 0
@@ -67,10 +68,18 @@ class SessionDaemonState:
     start_time: Optional[str] = None  # ISO timestamp when session started
     permissiveness_mode: str = "normal"  # normal, permissive, bypass
     start_directory: Optional[str] = None  # For git diff stats
+    is_asleep: bool = False  # Agent is paused and excluded from stats (#70)
 
-    # Activity summary (from SummarizerComponent)
+    # Agent priority value (#61)
+    agent_value: int = 1000  # Default 1000, higher = more important
+
+    # Activity summaries (from SummarizerComponent)
+    # Short: current activity - what's happening right now (~50 chars)
     activity_summary: str = ""
     activity_summary_updated: Optional[str] = None  # ISO timestamp
+    # Context: wider context - what's being worked on overall (~80 chars)
+    activity_summary_context: str = ""
+    activity_summary_context_updated: Optional[str] = None  # ISO timestamp
 
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""
@@ -83,6 +92,7 @@ class SessionDaemonState:
             "status_since": self.status_since,
             "green_time_seconds": self.green_time_seconds,
             "non_green_time_seconds": self.non_green_time_seconds,
+            "sleep_time_seconds": self.sleep_time_seconds,
             "interaction_count": self.interaction_count,
             "input_tokens": self.input_tokens,
             "output_tokens": self.output_tokens,
@@ -98,8 +108,12 @@ class SessionDaemonState:
             "start_time": self.start_time,
             "permissiveness_mode": self.permissiveness_mode,
             "start_directory": self.start_directory,
+            "is_asleep": self.is_asleep,
+            "agent_value": self.agent_value,
             "activity_summary": self.activity_summary,
             "activity_summary_updated": self.activity_summary_updated,
+            "activity_summary_context": self.activity_summary_context,
+            "activity_summary_context_updated": self.activity_summary_context_updated,
         }
 
     @classmethod
@@ -114,6 +128,7 @@ class SessionDaemonState:
             status_since=data.get("status_since"),
             green_time_seconds=data.get("green_time_seconds", 0.0),
             non_green_time_seconds=data.get("non_green_time_seconds", 0.0),
+            sleep_time_seconds=data.get("sleep_time_seconds", 0.0),
             interaction_count=data.get("interaction_count", 0),
             input_tokens=data.get("input_tokens", 0),
             output_tokens=data.get("output_tokens", 0),
@@ -129,8 +144,12 @@ class SessionDaemonState:
             start_time=data.get("start_time"),
             permissiveness_mode=data.get("permissiveness_mode", "normal"),
             start_directory=data.get("start_directory"),
+            is_asleep=data.get("is_asleep", False),
+            agent_value=data.get("agent_value", 1000),
             activity_summary=data.get("activity_summary", ""),
             activity_summary_updated=data.get("activity_summary_updated"),
+            activity_summary_context=data.get("activity_summary_context", ""),
+            activity_summary_context_updated=data.get("activity_summary_context_updated"),
         )
 
 
@@ -162,6 +181,7 @@ class MonitorDaemonState:
     # Summary metrics (computed from sessions)
     total_green_time: float = 0.0
     total_non_green_time: float = 0.0
+    total_sleep_time: float = 0.0
     green_sessions: int = 0
     non_green_sessions: int = 0
 
@@ -180,12 +200,6 @@ class MonitorDaemonState:
     relay_last_push: Optional[str] = None  # ISO timestamp of last successful push
     relay_last_status: str = "disabled"  # "ok", "error", "disabled"
 
-    # Summarizer status
-    summarizer_enabled: bool = False
-    summarizer_available: bool = False  # True if OPENAI_API_KEY is set
-    summarizer_calls: int = 0
-    summarizer_cost_usd: float = 0.0
-
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""
         return {
@@ -202,6 +216,7 @@ class MonitorDaemonState:
             "presence_idle_seconds": self.presence_idle_seconds,
             "total_green_time": self.total_green_time,
             "total_non_green_time": self.total_non_green_time,
+            "total_sleep_time": self.total_sleep_time,
             "green_sessions": self.green_sessions,
             "non_green_sessions": self.non_green_sessions,
             "total_supervisions": self.total_supervisions,
@@ -213,10 +228,6 @@ class MonitorDaemonState:
             "relay_enabled": self.relay_enabled,
             "relay_last_push": self.relay_last_push,
             "relay_last_status": self.relay_last_status,
-            "summarizer_enabled": self.summarizer_enabled,
-            "summarizer_available": self.summarizer_available,
-            "summarizer_calls": self.summarizer_calls,
-            "summarizer_cost_usd": self.summarizer_cost_usd,
         }
 
     @classmethod
@@ -241,6 +252,7 @@ class MonitorDaemonState:
             presence_idle_seconds=data.get("presence_idle_seconds"),
             total_green_time=data.get("total_green_time", 0.0),
             total_non_green_time=data.get("total_non_green_time", 0.0),
+            total_sleep_time=data.get("total_sleep_time", 0.0),
             green_sessions=data.get("green_sessions", 0),
             non_green_sessions=data.get("non_green_sessions", 0),
             total_supervisions=data.get("total_supervisions", 0),
@@ -252,16 +264,13 @@ class MonitorDaemonState:
             relay_enabled=data.get("relay_enabled", False),
             relay_last_push=data.get("relay_last_push"),
             relay_last_status=data.get("relay_last_status", "disabled"),
-            summarizer_enabled=data.get("summarizer_enabled", False),
-            summarizer_available=data.get("summarizer_available", False),
-            summarizer_calls=data.get("summarizer_calls", 0),
-            summarizer_cost_usd=data.get("summarizer_cost_usd", 0.0),
         )
 
     def update_summaries(self) -> None:
         """Recompute summary metrics from session data."""
         self.total_green_time = sum(s.green_time_seconds for s in self.sessions)
         self.total_non_green_time = sum(s.non_green_time_seconds for s in self.sessions)
+        self.total_sleep_time = sum(s.sleep_time_seconds for s in self.sessions)
         self.green_sessions = sum(1 for s in self.sessions if s.current_status == "running")
         self.non_green_sessions = len(self.sessions) - self.green_sessions
         self.total_supervisions = sum(s.steers_count for s in self.sessions)

overcode/pid_utils.py

@@ -88,6 +88,10 @@ def acquire_daemon_lock(pid_file: Path) -> Tuple[bool, Optional[int]]:
     Uses file locking to prevent TOCTOU race conditions when multiple
     processes try to start the daemon simultaneously.
 
+    IMPORTANT: The lock is held for the daemon's entire lifetime. The lock
+    file descriptor is stored in a module-level variable and released
+    automatically when the process exits (normal or crash).
+
     Args:
         pid_file: Path to the PID file
 
@@ -96,6 +100,8 @@ def acquire_daemon_lock(pid_file: Path) -> Tuple[bool, Optional[int]]:
         - (True, None) if lock was acquired and PID file written
         - (False, existing_pid) if another daemon is already running
     """
+    global _held_lock_fd
+
     pid_file.parent.mkdir(parents=True, exist_ok=True)
 
     # Use a separate lock file to avoid truncation issues
@@ -110,12 +116,14 @@ def acquire_daemon_lock(pid_file: Path) -> Tuple[bool, Optional[int]]:
             fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
 
             # We have the lock - now check if another daemon is running
+            # (handles case where previous daemon crashed without releasing lock)
             if pid_file.exists():
                 try:
                     existing_pid = int(pid_file.read_text().strip())
                     # Check if process is still alive
                     os.kill(existing_pid, 0)
                     # Process exists - another daemon is running
+                    # This shouldn't happen if locking works, but check anyway
                     fcntl.flock(fd, fcntl.LOCK_UN)
                     os.close(fd)
                     return False, existing_pid
@@ -127,9 +135,10 @@ def acquire_daemon_lock(pid_file: Path) -> Tuple[bool, Optional[int]]:
             current_pid = os.getpid()
             pid_file.write_text(str(current_pid))
 
-            # Release the lock (but keep file for tracking)
-            fcntl.flock(fd, fcntl.LOCK_UN)
-            os.close(fd)
+            # IMPORTANT: Keep the lock held for the daemon's entire lifetime!
+            # The OS will automatically release it when the process exits.
+            # Store fd in module-level variable to prevent garbage collection.
+            _held_lock_fd = fd
 
             return True, None
 
@@ -150,6 +159,11 @@ def acquire_daemon_lock(pid_file: Path) -> Tuple[bool, Optional[int]]:
         return False, None
 
 
+# Module-level variable to hold the lock file descriptor.
+# This prevents garbage collection from closing the fd and releasing the lock.
+_held_lock_fd: Optional[int] = None
+
+
 def count_daemon_processes(pattern: str = "monitor_daemon", session: str = None) -> int:
     """Count running daemon processes matching the pattern.
 

overcode/session_manager.py

@@ -44,6 +44,7 @@ class SessionStats:
     state_since: Optional[str] = None  # ISO timestamp when current state started
     green_time_seconds: float = 0.0  # time spent in "running" state
     non_green_time_seconds: float = 0.0  # time spent in non-running states
+    sleep_time_seconds: float = 0.0  # time spent in "asleep" state
     last_time_accumulation: Optional[str] = None  # ISO timestamp when times were last accumulated
 
     def to_dict(self) -> dict:
@@ -91,6 +92,17 @@ class Session:
     # Sleep mode - agent is paused and excluded from stats
     is_asleep: bool = False
 
+    # Agent value - priority indicator for sorting/attention (#61)
+    # Default 1000, higher = more important
+    agent_value: int = 1000
+
+    # Human annotation - user's notes about this agent (#74)
+    human_annotation: str = ""
+
+    # Claude sessionIds owned by this overcode session (#119)
+    # Used to accurately calculate context window for this specific agent
+    claude_session_ids: List[str] = field(default_factory=list)
+
     def to_dict(self) -> dict:
         data = asdict(self)
         # Convert stats to dict
@@ -607,3 +619,45 @@ class SessionManager:
     def set_permissiveness(self, session_id: str, mode: str):
         """Set permissiveness mode (normal, permissive, strict)"""
         self.update_session(session_id, permissiveness_mode=mode)
+
+    def set_agent_value(self, session_id: str, value: int):
+        """Set agent value for priority sorting (#61).
+
+        Args:
+            session_id: The session ID
+            value: Priority value (default 1000, higher = more important)
+        """
+        self.update_session(session_id, agent_value=value)
+
+    def set_human_annotation(self, session_id: str, annotation: str):
+        """Set human annotation for a session (#74)."""
+        self.update_session(session_id, human_annotation=annotation)
+
+    def add_claude_session_id(self, session_id: str, claude_session_id: str) -> bool:
+        """Add a Claude sessionId to a session's owned list if not already present.
+
+        This tracks which Claude sessionIds belong to this overcode agent,
+        enabling accurate context window calculation when multiple agents
+        run in the same directory (#119).
+
+        Args:
+            session_id: The overcode session ID
+            claude_session_id: The Claude Code sessionId to add
+
+        Returns:
+            True if the sessionId was added, False if already present or session not found
+        """
+        session = self.get_session(session_id)
+        if not session or claude_session_id in session.claude_session_ids:
+            return False
+
+        def do_update(state):
+            if session_id in state:
+                ids = state[session_id].get('claude_session_ids', [])
+                if claude_session_id not in ids:
+                    ids.append(claude_session_id)
+                    state[session_id]['claude_session_ids'] = ids
+            return state
+
+        self._atomic_update(do_update)
+        return True

overcode/settings.py

@@ -216,6 +216,12 @@ class UserConfig:
     default_standing_instructions: str = ""
     tmux_session: str = "agents"
 
+    # Token pricing (per million tokens) - defaults to Opus 4.5
+    price_input: float = 5.0        # $/MTok for input tokens
+    price_output: float = 25.0      # $/MTok for output tokens
+    price_cache_write: float = 6.25  # $/MTok for cache creation
+    price_cache_read: float = 0.50   # $/MTok for cache reads
+
     @classmethod
     def load(cls) -> "UserConfig":
         """Load configuration from config file."""
@@ -230,11 +236,18 @@ class UserConfig:
                 if not isinstance(data, dict):
                     return cls()
 
+                # Load pricing config (nested under 'pricing' key)
+                pricing = data.get("pricing", {})
+
                 return cls(
                     default_standing_instructions=data.get(
                         "default_standing_instructions", ""
                     ),
                     tmux_session=data.get("tmux_session", "agents"),
+                    price_input=pricing.get("input", 5.0),
+                    price_output=pricing.get("output", 25.0),
+                    price_cache_write=pricing.get("cache_write", 6.25),
+                    price_cache_read=pricing.get("cache_read", 0.50),
                 )
         except (yaml.YAMLError, IOError):
             return cls()
@@ -380,6 +393,13 @@ class TUIPreferences:
     daemon_panel_visible: bool = False
     view_mode: str = "tree"  # tree, list_preview
     tmux_sync: bool = False  # sync navigation to external tmux pane
+    show_terminated: bool = False  # keep killed sessions visible in timeline
+    hide_asleep: bool = False  # hide sleeping agents from display
+    sort_mode: str = "alphabetical"  # alphabetical, by_status, by_value (#61)
+    summary_content_mode: str = "ai_short"  # ai_short, ai_long, orders, annotation (#98)
+    baseline_minutes: int = 60  # 0=now (instantaneous), 15/30/.../180 = minutes back for mean spin
+    monochrome: bool = False  # B&W mode for terminals with ANSI issues (#138)
+    show_cost: bool = False  # Show $ cost instead of token counts
     # Session IDs of stalled agents that have been visited by the user
     visited_stalled_agents: Set[str] = field(default_factory=set)
 
@@ -405,6 +425,13 @@ class TUIPreferences:
                     daemon_panel_visible=data.get("daemon_panel_visible", False),
                     view_mode=data.get("view_mode", "tree"),
                     tmux_sync=data.get("tmux_sync", False),
+                    show_terminated=data.get("show_terminated", False),
+                    hide_asleep=data.get("hide_asleep", False),
+                    sort_mode=data.get("sort_mode", "alphabetical"),
+                    summary_content_mode=data.get("summary_content_mode", "ai_short"),
+                    baseline_minutes=data.get("baseline_minutes", 0),
+                    monochrome=data.get("monochrome", False),
+                    show_cost=data.get("show_cost", False),
                     visited_stalled_agents=set(data.get("visited_stalled_agents", [])),
                 )
         except (json.JSONDecodeError, IOError):
@@ -425,6 +452,13 @@ class TUIPreferences:
                     "daemon_panel_visible": self.daemon_panel_visible,
                     "view_mode": self.view_mode,
                     "tmux_sync": self.tmux_sync,
+                    "show_terminated": self.show_terminated,
+                    "hide_asleep": self.hide_asleep,
+                    "sort_mode": self.sort_mode,
+                    "summary_content_mode": self.summary_content_mode,
+                    "baseline_minutes": self.baseline_minutes,
+                    "monochrome": self.monochrome,
+                    "show_cost": self.show_cost,
                     "visited_stalled_agents": list(self.visited_stalled_agents),
                 }, f, indent=2)
         except (IOError, OSError):

overcode/status_constants.py

@@ -119,7 +119,7 @@ AGENT_TIMELINE_CHARS = {
     STATUS_WAITING_SUPERVISOR: "▒",
     STATUS_WAITING_USER: "░",
     STATUS_TERMINATED: "×",  # Small X - terminated
-    STATUS_ASLEEP: "z",  # Lowercase z for sleeping
+    STATUS_ASLEEP: "░",  # Light shade hatching (grey) - sleeping/paused
 }
 
 

overcode/status_detector.py

@@ -19,6 +19,7 @@ from .status_patterns import (
     is_command_menu_line,
     count_command_menu_lines,
     clean_line,
+    strip_ansi,
     StatusPatterns,
 )
 
@@ -94,12 +95,17 @@ class StatusDetector:
         if not content:
             return self.STATUS_WAITING_USER, "Unable to read pane", ""
 
+        # Strip ANSI escape sequences for pattern matching
+        # The raw content (with colors) is returned for display, but pattern
+        # matching needs plain text since escape codes break string matching
+        clean_content = strip_ansi(content)
+
         # Content change detection - if content is changing, Claude is actively working
         # Key by session.id, not window index, to avoid stale hashes when windows are recycled
         # IMPORTANT: Filter out status bar lines before hashing to avoid false positives
         # from dynamic status bar elements (token counts, elapsed time) that update when idle
         session_id = session.id
-        content_for_hash = self._filter_status_bar_for_hash(content)
+        content_for_hash = self._filter_status_bar_for_hash(clean_content)
         content_hash = hash(content_for_hash)
         content_changed = False
         if session_id in self._previous_content:
@@ -107,7 +113,7 @@ class StatusDetector:
         self._previous_content[session_id] = content_hash
         self._content_changed[session_id] = content_changed
 
-        lines = content.strip().split('\n')
+        lines = clean_content.strip().split('\n')
         # Get more lines for better context (menu prompts can be 5+ lines)
         last_lines = [l.strip() for l in lines[-10:] if l.strip()]
 

overcode/status_patterns.py

@@ -10,9 +10,28 @@ Claude's current state. Centralizing these makes them:
 Each pattern set includes documentation about when it's used and what it matches.
 """
 
+import re
 from dataclasses import dataclass, field
 from typing import List
 
+# Regex to match ANSI escape sequences (colors, cursor movement, etc.)
+ANSI_ESCAPE_PATTERN = re.compile(r'\x1b\[[0-9;]*[a-zA-Z]')
+
+
+def strip_ansi(text: str) -> str:
+    """Remove ANSI escape sequences from text.
+
+    This is needed because tmux capture_pane with escape_sequences=True
+    preserves color codes, but pattern matching needs plain text.
+
+    Args:
+        text: Text potentially containing ANSI escape sequences
+
+    Returns:
+        Text with all ANSI escape sequences removed
+    """
+    return ANSI_ESCAPE_PATTERN.sub('', text)
+
 
 @dataclass
 class StatusPatterns: