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

overcode/__init__.py

@@ -2,4 +2,4 @@
 Overcode - A supervisor for managing multiple Claude Code instances.
 """
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"

overcode/cli.py

@@ -150,7 +150,7 @@ def list_agents(session: SessionOption = "agents"):
         uptime = calculate_uptime(sess.start_time) if sess.start_time else "?"
 
         # Get state times using shared helper
-        green_time, non_green_time = get_current_state_times(sess.stats)
+        green_time, non_green_time, sleep_time = get_current_state_times(sess.stats, is_asleep=sess.is_asleep)
 
         # Get stats from Claude Code history and session files
         stats = get_session_stats(sess)
@@ -159,9 +159,14 @@ def list_agents(session: SessionOption = "agents"):
         else:
             stats_display = " -i     -"
 
+        # Build time display - show sleep time if agent has slept
+        time_display = f"▶{format_duration(green_time):>5} ⏸{format_duration(non_green_time):>5}"
+        if sleep_time > 0:
+            time_display += f" 💤{format_duration(sleep_time):>5}"
+
         print(
             f"{symbol} {sess.name:<16} ↑{uptime:>5}  "
-            f"▶{format_duration(green_time):>5} ⏸{format_duration(non_green_time):>5}  "
+            f"{time_display}  "
             f"{stats_display}  {activity[:50]}"
         )
 

overcode/implementations.py

@@ -17,7 +17,14 @@ from libtmux._internal.query_list import ObjectDoesNotExist
 
 
 class RealTmux:
-    """Production implementation of TmuxInterface using libtmux"""
+    """Production implementation of TmuxInterface using libtmux.
+
+    Includes caching to reduce subprocess overhead. libtmux spawns a new
+    subprocess for every tmux command, which is expensive at high frequencies.
+    """
+
+    # Cache TTL in seconds - pane objects rarely change
+    _CACHE_TTL = 30.0
 
     def __init__(self, socket_name: Optional[str] = None):
         """Initialize with optional socket name for test isolation.
@@ -27,6 +34,10 @@ class RealTmux:
         # Support OVERCODE_TMUX_SOCKET env var for testing
         self._socket_name = socket_name or os.environ.get("OVERCODE_TMUX_SOCKET")
         self._server: Optional[libtmux.Server] = None
+        # Cache: (session_name, window_index) -> (pane, timestamp)
+        self._pane_cache: Dict[tuple, tuple] = {}
+        # Cache: session_name -> (session_obj, timestamp)
+        self._session_cache: Dict[str, tuple] = {}
 
     @property
     def server(self) -> libtmux.Server:
@@ -39,9 +50,17 @@ class RealTmux:
         return self._server
 
     def _get_session(self, session: str) -> Optional[libtmux.Session]:
-        """Get a session by name, or None if it doesn't exist."""
+        """Get a session by name, with caching."""
+        now = time.time()
+        if session in self._session_cache:
+            cached_session, cached_time = self._session_cache[session]
+            if now - cached_time < self._CACHE_TTL:
+                return cached_session
+
         try:
-            return self.server.sessions.get(session_name=session)
+            sess = self.server.sessions.get(session_name=session)
+            self._session_cache[session] = (sess, now)
+            return sess
         except (LibTmuxException, ObjectDoesNotExist):
             return None
 
@@ -56,11 +75,42 @@ class RealTmux:
             return None
 
     def _get_pane(self, session: str, window: int) -> Optional[libtmux.Pane]:
-        """Get the first pane of a window."""
+        """Get the first pane of a window, with caching."""
+        cache_key = (session, window)
+        now = time.time()
+
+        # Check cache first
+        if cache_key in self._pane_cache:
+            cached_pane, cached_time = self._pane_cache[cache_key]
+            if now - cached_time < self._CACHE_TTL:
+                return cached_pane
+
+        # Cache miss - fetch from tmux
         win = self._get_window(session, window)
         if win is None or not win.panes:
             return None
-        return win.panes[0]
+        pane = win.panes[0]
+        self._pane_cache[cache_key] = (pane, now)
+        return pane
+
+    def invalidate_cache(self, session: str = None, window: int = None) -> None:
+        """Invalidate cached objects.
+
+        Args:
+            session: If provided, invalidate only this session's cache
+            window: If provided with session, invalidate only this window's pane
+        """
+        if session is None:
+            self._pane_cache.clear()
+            self._session_cache.clear()
+        elif window is not None:
+            self._pane_cache.pop((session, window), None)
+        else:
+            self._session_cache.pop(session, None)
+            # Remove all panes for this session
+            keys_to_remove = [k for k in self._pane_cache if k[0] == session]
+            for k in keys_to_remove:
+                del self._pane_cache[k]
 
     def capture_pane(self, session: str, window: int, lines: int = 100) -> Optional[str]:
         try:
@@ -74,6 +124,8 @@ class RealTmux:
                 return '\n'.join(captured)
             return captured
         except LibTmuxException:
+            # Pane may have been killed - invalidate cache and retry once
+            self.invalidate_cache(session, window)
             return None
 
     def send_keys(self, session: str, window: int, keys: str, enter: bool = True) -> bool:
@@ -85,9 +137,23 @@ class RealTmux:
             # For Claude Code: text and Enter must be sent as SEPARATE commands
             # with a small delay, otherwise Claude Code doesn't process the Enter.
             if keys:
-                pane.send_keys(keys, enter=False)
-                # Small delay for Claude Code to process text
-                time.sleep(0.1)
+                # Special handling for ! commands (#139)
+                # Claude Code requires ! to be sent separately to trigger mode switch
+                # to bash mode before receiving the rest of the command
+                if keys.startswith('!') and len(keys) > 1:
+                    # Send ! first
+                    pane.send_keys('!', enter=False)
+                    # Wait for mode switch to process
+                    time.sleep(0.15)
+                    # Send the rest (without the !)
+                    rest = keys[1:]
+                    if rest:
+                        pane.send_keys(rest, enter=False)
+                        time.sleep(0.1)
+                else:
+                    pane.send_keys(keys, enter=False)
+                    # Small delay for Claude Code to process text
+                    time.sleep(0.1)
 
             if enter:
                 pane.send_keys('', enter=True)

overcode/monitor_daemon.py

@@ -17,7 +17,7 @@ This separation ensures:
 - Clean interface contract via MonitorDaemonState
 - Platform-agnostic core (presence is optional)
 
-TODO: Add unit tests (currently 0% coverage)
+Pure business logic is extracted to monitor_daemon_core.py for testability.
 """
 
 import os
@@ -56,6 +56,14 @@ from .config import get_relay_config
 from .status_constants import STATUS_ASLEEP, STATUS_RUNNING, STATUS_TERMINATED
 from .status_detector import StatusDetector
 from .status_history import log_agent_status
+from .monitor_daemon_core import (
+    calculate_time_accumulation,
+    calculate_cost_estimate,
+    calculate_total_tokens,
+    calculate_median,
+    should_sync_stats,
+    parse_datetime_safe,
+)
 
 
 # Check for macOS presence APIs (optional)
@@ -202,8 +210,8 @@ class MonitorDaemon:
         self.last_state_times: Dict[str, datetime] = {}
         self.operation_start_times: Dict[str, datetime] = {}
 
-        # Stats sync throttling - start with min time to force immediate sync on first loop
-        self._last_stats_sync = datetime.min
+        # Stats sync throttling - None forces immediate sync on first loop
+        self._last_stats_sync: Optional[datetime] = None
         self._stats_sync_interval = 60  # seconds
 
         # Relay configuration (for pushing state to cloud)
@@ -271,6 +279,7 @@ class MonitorDaemon:
             status_since=stats.state_since,
             green_time_seconds=stats.green_time_seconds,
             non_green_time_seconds=stats.non_green_time_seconds,
+            sleep_time_seconds=stats.sleep_time_seconds,
             interaction_count=stats.interaction_count,
             input_tokens=stats.input_tokens,
             output_tokens=stats.output_tokens,
@@ -300,18 +309,11 @@ class MonitorDaemon:
         if last_time is None:
             # First observation after daemon (re)start - use last_time_accumulation
             # to avoid re-adding time that was already accumulated before restart
-            if current_stats.last_time_accumulation:
-                try:
-                    last_time = datetime.fromisoformat(current_stats.last_time_accumulation)
-                except ValueError:
-                    last_time = now
-            elif current_stats.state_since:
+            last_time = parse_datetime_safe(current_stats.last_time_accumulation)
+            if last_time is None:
                 # Fallback for sessions without last_time_accumulation
-                try:
-                    last_time = datetime.fromisoformat(current_stats.state_since)
-                except ValueError:
-                    last_time = now
-            else:
+                last_time = parse_datetime_safe(current_stats.state_since)
+            if last_time is None:
                 last_time = now
             self.last_state_times[session_id] = last_time
             return  # Don't accumulate on first observation
@@ -321,41 +323,33 @@ class MonitorDaemon:
         if elapsed <= 0:
             return
 
-        # Accumulate time based on state
-        green_time = current_stats.green_time_seconds
-        non_green_time = current_stats.non_green_time_seconds
+        # Get session start time for capping
+        session_start = parse_datetime_safe(session.start_time)
 
-        if status == STATUS_RUNNING:
-            green_time += elapsed
-        elif status not in (STATUS_TERMINATED, STATUS_ASLEEP):
-            # Only count non-green time for non-terminated/non-asleep states (#68)
-            non_green_time += elapsed
-        # else: terminated or asleep - don't accumulate time
+        # Use pure function for time accumulation (with sleep time tracking #141)
+        prev_status = self.previous_states.get(session_id, status)
+        result = calculate_time_accumulation(
+            current_status=status,
+            previous_status=prev_status,
+            elapsed_seconds=elapsed,
+            current_green=current_stats.green_time_seconds,
+            current_non_green=current_stats.non_green_time_seconds,
+            current_sleep=current_stats.sleep_time_seconds,
+            session_start=session_start,
+            now=now,
+        )
 
-        # INVARIANT CHECK: accumulated time should never exceed uptime
-        # This catches bugs like multiple daemons running simultaneously
-        if session.start_time:
-            try:
-                session_start = datetime.fromisoformat(session.start_time)
-                max_allowed = (now - session_start).total_seconds()
-                total_accumulated = green_time + non_green_time
-
-                if total_accumulated > max_allowed * 1.1:  # 10% tolerance for timing jitter
-                    # Reset to sane values based on ratio
-                    ratio = max_allowed / total_accumulated if total_accumulated > 0 else 1.0
-                    green_time = green_time * ratio
-                    non_green_time = non_green_time * ratio
-                    self.log.warn(
-                        f"[{session.name}] Time tracking reset: "
-                        f"accumulated {total_accumulated/3600:.1f}h > uptime {max_allowed/3600:.1f}h"
-                    )
-            except (ValueError, TypeError):
-                pass
+        if result.was_capped:
+            total = current_stats.green_time_seconds + current_stats.non_green_time_seconds + current_stats.sleep_time_seconds
+            max_allowed = (now - session_start).total_seconds() if session_start else 0
+            self.log.warn(
+                f"[{session.name}] Time tracking reset: "
+                f"accumulated {total/3600:.1f}h > uptime {max_allowed/3600:.1f}h"
+            )
 
         # Update state tracking
-        prev_status = self.previous_states.get(session_id, status)
         state_since = current_stats.state_since
-        if prev_status != status:
+        if result.state_changed:
             state_since = now.isoformat()
         elif not state_since:
             # Initialize state_since if never set (e.g., new session)
@@ -366,8 +360,9 @@ class MonitorDaemon:
             session_id,
             current_state=status,
             state_since=state_since,
-            green_time_seconds=green_time,
-            non_green_time_seconds=non_green_time,
+            green_time_seconds=result.green_seconds,
+            non_green_time_seconds=result.non_green_seconds,
+            sleep_time_seconds=result.sleep_seconds,
             last_time_accumulation=now.isoformat(),
         )
 
@@ -394,19 +389,25 @@ class MonitorDaemon:
                 return
 
             now = datetime.now()
-            total_tokens = (
-                stats.input_tokens +
-                stats.output_tokens +
-                stats.cache_creation_tokens +
-                stats.cache_read_tokens
+            total_tokens = calculate_total_tokens(
+                stats.input_tokens,
+                stats.output_tokens,
+                stats.cache_creation_tokens,
+                stats.cache_read_tokens,
             )
 
-            # Estimate cost
-            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
+            # Estimate cost using configured pricing (defaults to Opus 4.5)
+            from .settings import get_user_config
+            pricing = get_user_config()
+            cost_estimate = calculate_cost_estimate(
+                stats.input_tokens,
+                stats.output_tokens,
+                stats.cache_creation_tokens,
+                stats.cache_read_tokens,
+                price_input=pricing.price_input,
+                price_output=pricing.price_output,
+                price_cache_write=pricing.price_cache_write,
+                price_cache_read=pricing.price_cache_read,
             )
 
             self.session_manager.update_stats(
@@ -425,13 +426,7 @@ class MonitorDaemon:
 
     def _calculate_median_work_time(self, operation_times: List[float]) -> float:
         """Calculate median operation time."""
-        if not operation_times:
-            return 0.0
-        sorted_times = sorted(operation_times)
-        n = len(sorted_times)
-        if n % 2 == 0:
-            return (sorted_times[n // 2 - 1] + sorted_times[n // 2]) / 2
-        return sorted_times[n // 2]
+        return calculate_median(operation_times)
 
     def calculate_interval(self, sessions: list, all_waiting_user: bool) -> int:
         """Calculate appropriate loop interval.
@@ -590,7 +585,7 @@ class MonitorDaemon:
 
                 # Sync Claude Code stats BEFORE building session_states so token counts are fresh
                 # This ensures the first loop has accurate data (fixes #103)
-                if (now - self._last_stats_sync).total_seconds() >= self._stats_sync_interval:
+                if should_sync_stats(self._last_stats_sync, now, self._stats_sync_interval):
                     for session in sessions:
                         self.sync_claude_code_stats(session)
                     self._last_stats_sync = now

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
@@ -91,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,
@@ -126,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),
@@ -178,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
 
@@ -212,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,
@@ -247,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),
@@ -264,6 +270,7 @@ class MonitorDaemonState:
         """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/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: