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

overcode/implementations.py

@@ -1,142 +1,167 @@
 """
 Real implementations of protocol interfaces.
 
-These are production implementations that make actual subprocess calls
-to tmux, perform real file I/O, etc.
+These are production implementations that use libtmux for tmux operations
+and perform real file I/O.
 """
 
 import json
-import subprocess
 import os
 import time
 from pathlib import Path
 from typing import Optional, List, Dict, Any
 
+import libtmux
+from libtmux.exc import LibTmuxException
+from libtmux._internal.query_list import ObjectDoesNotExist
+
 
 class RealTmux:
-    """Production implementation of TmuxInterface using subprocess"""
+    """Production implementation of TmuxInterface using libtmux"""
+
+    def __init__(self, socket_name: Optional[str] = None):
+        """Initialize with optional socket name for test isolation.
+
+        If no socket_name is provided, checks OVERCODE_TMUX_SOCKET env var.
+        """
+        # 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
+
+    @property
+    def server(self) -> libtmux.Server:
+        """Lazy-load the tmux server connection."""
+        if self._server is None:
+            if self._socket_name:
+                self._server = libtmux.Server(socket_name=self._socket_name)
+            else:
+                self._server = libtmux.Server()
+        return self._server
+
+    def _get_session(self, session: str) -> Optional[libtmux.Session]:
+        """Get a session by name, or None if it doesn't exist."""
+        try:
+            return self.server.sessions.get(session_name=session)
+        except (LibTmuxException, ObjectDoesNotExist):
+            return None
 
-    def capture_pane(self, session: str, window: int, lines: int = 100) -> Optional[str]:
+    def _get_window(self, session: str, window: int) -> Optional[libtmux.Window]:
+        """Get a window by session name and window index."""
+        sess = self._get_session(session)
+        if sess is None:
+            return None
         try:
-            result = subprocess.run(
-                ["tmux", "capture-pane", "-t", f"{session}:{window}",
-                 "-p", "-S", f"-{lines}"],
-                capture_output=True, text=True, timeout=5
-            )
-            if result.returncode == 0:
-                return result.stdout
+            return sess.windows.get(window_index=str(window))
+        except (LibTmuxException, ObjectDoesNotExist):
             return None
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+
+    def _get_pane(self, session: str, window: int) -> Optional[libtmux.Pane]:
+        """Get the first pane of a window."""
+        win = self._get_window(session, window)
+        if win is None or not win.panes:
+            return None
+        return win.panes[0]
+
+    def capture_pane(self, session: str, window: int, lines: int = 100) -> Optional[str]:
+        try:
+            pane = self._get_pane(session, window)
+            if pane is None:
+                return None
+            # capture_pane returns list of lines
+            # escape_sequences=True preserves ANSI color codes for TUI rendering
+            captured = pane.capture_pane(start=-lines, escape_sequences=True)
+            if isinstance(captured, list):
+                return '\n'.join(captured)
+            return captured
+        except LibTmuxException:
             return None
 
     def send_keys(self, session: str, window: int, keys: str, enter: bool = True) -> bool:
         try:
+            pane = self._get_pane(session, window)
+            if pane is None:
+                return False
+
             # For Claude Code: text and Enter must be sent as SEPARATE commands
             # with a small delay, otherwise Claude Code doesn't process the Enter.
-            target = f"{session}:{window}"
-
-            # Send text first (if any)
             if keys:
-                result = subprocess.run(
-                    ["tmux", "send-keys", "-t", target, keys],
-                    timeout=5, capture_output=True
-                )
-                if result.returncode != 0:
-                    return False
+                pane.send_keys(keys, enter=False)
                 # Small delay for Claude Code to process text
                 time.sleep(0.1)
 
-            # Send Enter separately
             if enter:
-                result = subprocess.run(
-                    ["tmux", "send-keys", "-t", target, "Enter"],
-                    timeout=5, capture_output=True
-                )
-                if result.returncode != 0:
-                    return False
+                pane.send_keys('', enter=True)
 
             return True
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+        except LibTmuxException:
             return False
 
     def has_session(self, session: str) -> bool:
         try:
-            result = subprocess.run(
-                ["tmux", "has-session", "-t", session],
-                capture_output=True, timeout=5
-            )
-            return result.returncode == 0
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            return self.server.has_session(session)
+        except LibTmuxException:
             return False
 
     def new_session(self, session: str) -> bool:
         try:
-            result = subprocess.run(
-                ["tmux", "new-session", "-d", "-s", session],
-                capture_output=True, timeout=5
-            )
-            return result.returncode == 0
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            self.server.new_session(session_name=session, attach=False)
+            return True
+        except LibTmuxException:
             return False
 
     def new_window(self, session: str, name: str, command: Optional[List[str]] = None,
                    cwd: Optional[str] = None) -> Optional[int]:
         try:
-            cmd = ["tmux", "new-window", "-t", session, "-n", name, "-P", "-F", "#{window_index}"]
+            sess = self._get_session(session)
+            if sess is None:
+                return None
+
+            kwargs: Dict[str, Any] = {'window_name': name, 'attach': False}
             if cwd:
-                cmd.extend(["-c", cwd])
+                kwargs['start_directory'] = cwd
             if command:
-                cmd.append(" ".join(command))
+                kwargs['window_shell'] = ' '.join(command)
 
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
-            if result.returncode == 0:
-                return int(result.stdout.strip())
-            return None
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError, ValueError):
+            window = sess.new_window(**kwargs)
+            return int(window.window_index)
+        except (LibTmuxException, ValueError):
             return None
 
     def kill_window(self, session: str, window: int) -> bool:
         try:
-            result = subprocess.run(
-                ["tmux", "kill-window", "-t", f"{session}:{window}"],
-                capture_output=True, timeout=5
-            )
-            return result.returncode == 0
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            win = self._get_window(session, window)
+            if win is None:
+                return False
+            win.kill()
+            return True
+        except LibTmuxException:
             return False
 
     def kill_session(self, session: str) -> bool:
         try:
-            result = subprocess.run(
-                ["tmux", "kill-session", "-t", session],
-                capture_output=True, timeout=5
-            )
-            return result.returncode == 0
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            sess = self._get_session(session)
+            if sess is None:
+                return False
+            sess.kill()
+            return True
+        except LibTmuxException:
             return False
 
     def list_windows(self, session: str) -> List[Dict[str, Any]]:
         try:
-            result = subprocess.run(
-                ["tmux", "list-windows", "-t", session, "-F",
-                 "#{window_index}:#{window_name}:#{window_active}"],
-                capture_output=True, text=True, timeout=5
-            )
-            if result.returncode != 0:
+            sess = self._get_session(session)
+            if sess is None:
                 return []
 
             windows = []
-            for line in result.stdout.strip().split('\n'):
-                if line:
-                    parts = line.split(':')
-                    if len(parts) >= 3:
-                        windows.append({
-                            'index': int(parts[0]),
-                            'name': parts[1],
-                            'active': parts[2] == '1'
-                        })
+            for win in sess.windows:
+                windows.append({
+                    'index': int(win.window_index),
+                    'name': win.window_name,
+                    'active': win.window_active == '1'
+                })
             return windows
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+        except LibTmuxException:
             return []
 
     def attach(self, session: str) -> None:
@@ -145,12 +170,12 @@ class RealTmux:
     def select_window(self, session: str, window: int) -> bool:
         """Select a window in a tmux session (for external pane sync)."""
         try:
-            result = subprocess.run(
-                ["tmux", "select-window", "-t", f"{session}:{window}"],
-                capture_output=True, timeout=5
-            )
-            return result.returncode == 0
-        except (subprocess.TimeoutExpired, subprocess.SubprocessError):
+            win = self._get_window(session, window)
+            if win is None:
+                return False
+            win.select()
+            return True
+        except LibTmuxException:
             return False
 
 

overcode/monitor_daemon.py

@@ -30,7 +30,7 @@ from typing import Dict, List, Optional
 
 from .daemon_logging import BaseDaemonLogger
 from .daemon_utils import create_daemon_helpers
-from .history_reader import get_session_stats
+from .history_reader import get_session_stats, get_current_session_id_for_directory
 from .monitor_daemon_state import (
     MonitorDaemonState,
     SessionDaemonState,
@@ -53,10 +53,9 @@ from .settings import (
     get_supervisor_stats_path,
 )
 from .config import get_relay_config
-from .status_constants import STATUS_RUNNING, STATUS_TERMINATED
+from .status_constants import STATUS_ASLEEP, STATUS_RUNNING, STATUS_TERMINATED
 from .status_detector import StatusDetector
 from .status_history import log_agent_status
-from .summarizer_component import SummarizerComponent, SummarizerConfig
 
 
 # Check for macOS presence APIs (optional)
@@ -187,12 +186,6 @@ class MonitorDaemon:
         # Presence tracking (graceful degradation)
         self.presence = PresenceComponent()
 
-        # Summarizer component (graceful degradation if no API key)
-        self.summarizer = SummarizerComponent(
-            tmux_session=tmux_session,
-            config=SummarizerConfig(enabled=False),  # Off by default, enable via CLI
-        )
-
         # Logging - session-specific log file
         self.log = _create_monitor_logger(session=tmux_session)
 
@@ -209,8 +202,8 @@ class MonitorDaemon:
         self.last_state_times: Dict[str, datetime] = {}
         self.operation_start_times: Dict[str, datetime] = {}
 
-        # Stats sync throttling
-        self._last_stats_sync = datetime.now()
+        # Stats sync throttling - start with min time to force immediate sync on first loop
+        self._last_stats_sync = datetime.min
         self._stats_sync_interval = 60  # seconds
 
         # Relay configuration (for pushing state to cloud)
@@ -293,6 +286,8 @@ class MonitorDaemon:
             start_time=session.start_time,
             permissiveness_mode=session.permissiveness_mode,
             start_directory=session.start_directory,
+            is_asleep=session.is_asleep,
+            agent_value=session.agent_value,
         )
 
     def _update_state_time(self, session, status: str, now: datetime) -> None:
@@ -332,10 +327,10 @@ class MonitorDaemon:
 
         if status == STATUS_RUNNING:
             green_time += elapsed
-        elif status != STATUS_TERMINATED:
-            # Only count non-green time for non-terminated states
+        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 - don't accumulate time
+        # else: terminated or asleep - don't accumulate time
 
         # INVARIANT CHECK: accumulated time should never exceed uptime
         # This catches bugs like multiple daemons running simultaneously
@@ -381,6 +376,19 @@ class MonitorDaemon:
     def sync_claude_code_stats(self, session) -> None:
         """Sync token/interaction stats from Claude Code history files."""
         try:
+            # Capture current Claude sessionId if not already tracked (#119)
+            # This ensures accurate context window calculation for this agent
+            if session.start_directory:
+                try:
+                    session_start = datetime.fromisoformat(session.start_time)
+                    current_id = get_current_session_id_for_directory(
+                        session.start_directory, session_start
+                    )
+                    if current_id:
+                        self.session_manager.add_claude_session_id(session.id, current_id)
+                except (ValueError, TypeError):
+                    pass
+
             stats = get_session_stats(session)
             if stats is None:
                 return
@@ -481,13 +489,6 @@ class MonitorDaemon:
             except (json.JSONDecodeError, OSError):
                 pass
 
-        # Update summarizer stats
-        self.state.summarizer_available = self.summarizer.available
-        self.state.summarizer_enabled = self.summarizer.enabled
-        self.state.summarizer_calls = self.summarizer.total_calls
-        # Estimate cost: ~$0.0007 per call (4K input tokens + 150 output tokens)
-        self.state.summarizer_cost_usd = round(self.summarizer.total_calls * 0.0007, 4)
-
         self.state.save(self.state_path)
 
         # Push to relay if configured and interval elapsed
@@ -587,6 +588,13 @@ class MonitorDaemon:
                 # Get all sessions
                 sessions = self.session_manager.list_sessions()
 
+                # 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:
+                    for session in sessions:
+                        self.sync_claude_code_stats(session)
+                    self._last_stats_sync = now
+
                 # Detect status and track stats for each session
                 session_states = []
                 all_waiting_user = True
@@ -610,12 +618,14 @@ class MonitorDaemon:
                         continue
 
                     # Track stats and build state
-                    session_state = self.track_session_stats(session, status)
+                    # Use "asleep" status if session is marked as sleeping (#68)
+                    effective_status = STATUS_ASLEEP if session.is_asleep else status
+                    session_state = self.track_session_stats(session, effective_status)
                     session_state.current_activity = activity
                     session_states.append(session_state)
 
                     # Log status history to session-specific file
-                    log_agent_status(session.name, status, activity, history_file=self.history_path)
+                    log_agent_status(session.name, effective_status, activity, history_file=self.history_path)
 
                     # Track if any session is not waiting for user
                     if status != "waiting_user":
@@ -630,20 +640,6 @@ class MonitorDaemon:
                 for stale_id in stale_ids:
                     del self.previous_states[stale_id]
 
-                # Sync Claude Code stats periodically (git context is refreshed every loop above)
-                if (now - self._last_stats_sync).total_seconds() >= self._stats_sync_interval:
-                    for session in sessions:
-                        self.sync_claude_code_stats(session)
-                    self._last_stats_sync = now
-
-                # Update summaries (if enabled)
-                summaries = self.summarizer.update(sessions)
-                for session_state in session_states:
-                    summary = summaries.get(session_state.session_id)
-                    if summary:
-                        session_state.activity_summary = summary.text
-                        session_state.activity_summary_updated = summary.updated_at
-
                 # Calculate interval
                 interval = self.calculate_interval(sessions, all_waiting_user)
                 self.state.current_interval = interval
@@ -673,7 +669,6 @@ class MonitorDaemon:
         finally:
             self.log.info("Monitor daemon shutting down")
             self.presence.stop()
-            self.summarizer.stop()
             self.state.status = "stopped"
             self.state.save(self.state_path)
             remove_pid_file(self.pid_path)

overcode/monitor_daemon_state.py

@@ -67,10 +67,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."""
@@ -98,8 +106,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
@@ -129,8 +141,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"),
         )
 
 
@@ -180,12 +196,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 {
@@ -213,10 +223,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
@@ -252,10 +258,6 @@ 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:

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

@@ -91,6 +91,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 +618,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

@@ -380,6 +380,10 @@ 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)
     # Session IDs of stalled agents that have been visited by the user
     visited_stalled_agents: Set[str] = field(default_factory=set)
 
@@ -405,6 +409,10 @@ 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"),
                     visited_stalled_agents=set(data.get("visited_stalled_agents", [])),
                 )
         except (json.JSONDecodeError, IOError):
@@ -425,6 +433,10 @@ 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,
                     "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
 }