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

overcode/tui.py

@@ -1,5 +1,11 @@
 """
 Textual TUI for Overcode monitor.
+
+TODO: Split this file into smaller modules for maintainability:
+- tui_core.py: Main App class and core lifecycle
+- tui_panels.py: Panel widgets (StatusPanel, AgentPanel, etc.)
+- tui_commands.py: Command handlers and actions
+- tui_keybindings.py: Key bindings and input handling
 """
 
 from concurrent.futures import ThreadPoolExecutor
@@ -7,6 +13,7 @@ from datetime import datetime, timedelta
 from typing import List, Optional
 import subprocess
 import sys
+import time
 
 from textual.app import App, ComposeResult
 from textual.containers import Container, Vertical, ScrollableContainer, Horizontal
@@ -21,8 +28,9 @@ from rich.panel import Panel
 from .session_manager import SessionManager, Session
 from .launcher import ClaudeLauncher
 from .status_detector import StatusDetector
+from .status_constants import STATUS_WAITING_USER
 from .history_reader import get_session_stats, ClaudeSessionStats
-from .settings import signal_activity, get_session_dir, TUIPreferences, DAEMON_VERSION  # Activity signaling to daemon
+from .settings import signal_activity, get_session_dir, get_agent_history_path, TUIPreferences, DAEMON_VERSION  # Activity signaling to daemon
 from .monitor_daemon_state import MonitorDaemonState, get_monitor_daemon_state
 from .monitor_daemon import (
     is_monitor_daemon_running,
@@ -33,15 +41,22 @@ from .supervisor_daemon import (
     is_supervisor_daemon_running,
     stop_supervisor_daemon,
 )
+from .web_server import (
+    is_web_server_running,
+    get_web_server_url,
+    toggle_web_server,
+)
 from .config import get_default_standing_instructions
 from .status_history import read_agent_status_history
-from .presence_logger import read_presence_history
+from .presence_logger import read_presence_history, MACOS_APIS_AVAILABLE
 from .launcher import ClaudeLauncher
+from .implementations import RealTmux
 from .tui_helpers import (
     format_interval,
     format_ago,
     format_duration,
     format_tokens,
+    format_line_count,
     calculate_uptime,
     presence_state_to_char,
     agent_status_to_char,
@@ -84,14 +99,21 @@ class DaemonStatusBar(Static):
     Presence is shown only when available (macOS with monitor daemon running).
     """
 
-    def __init__(self, tmux_session: str = "agents", *args, **kwargs):
+    def __init__(self, tmux_session: str = "agents", session_manager: Optional["SessionManager"] = None, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.tmux_session = tmux_session
         self.monitor_state: Optional[MonitorDaemonState] = None
+        self._session_manager = session_manager
+        self._asleep_session_ids: set = set()  # Cache of asleep session IDs
 
     def update_status(self) -> None:
         """Refresh daemon state from file"""
         self.monitor_state = get_monitor_daemon_state(self.tmux_session)
+        # Update cache of asleep session IDs from session manager
+        if self._session_manager:
+            self._asleep_session_ids = {
+                s.id for s in self._session_manager.list_sessions() if s.is_asleep
+            }
         self.refresh()
 
     def render(self) -> Text:
@@ -156,13 +178,18 @@ class DaemonStatusBar(Static):
         # Spin rate stats (only when monitor running with sessions)
         if monitor_running and self.monitor_state.sessions:
             content.append(" │ ", style="dim")
-            sessions = self.monitor_state.sessions
-            total_agents = len(sessions)
-            green_now = self.monitor_state.green_sessions
+            # Filter out sleeping agents from stats
+            all_sessions = self.monitor_state.sessions
+            active_sessions = [s for s in all_sessions if s.session_id not in self._asleep_session_ids]
+            sleeping_count = len(all_sessions) - len(active_sessions)
 
-            # Calculate mean spin rate from green_time percentages
+            total_agents = len(active_sessions)
+            # Recalculate green_now excluding sleeping agents
+            green_now = sum(1 for s in active_sessions if s.current_status == "running")
+
+            # Calculate mean spin rate from green_time percentages (exclude sleeping)
             mean_spin = 0.0
-            for s in sessions:
+            for s in active_sessions:
                 total_time = s.green_time_seconds + s.non_green_time_seconds
                 if total_time > 0:
                     mean_spin += s.green_time_seconds / total_time
@@ -170,11 +197,13 @@ class DaemonStatusBar(Static):
             content.append("Spin: ", style="bold")
             content.append(f"{green_now}", style="bold green" if green_now > 0 else "dim")
             content.append(f"/{total_agents}", style="dim")
+            if sleeping_count > 0:
+                content.append(f" 💤{sleeping_count}", style="dim")  # Show sleeping count
             if mean_spin > 0:
                 content.append(f" μ{mean_spin:.1f}x", style="cyan")
 
-            # Safe break duration (time until 50%+ agents need attention)
-            safe_break = calculate_safe_break_duration(sessions)
+            # Safe break duration (time until 50%+ agents need attention) - exclude sleeping
+            safe_break = calculate_safe_break_duration(active_sessions)
             if safe_break is not None:
                 content.append(" │ ", style="dim")
                 content.append("☕", style="bold")
@@ -210,6 +239,17 @@ class DaemonStatusBar(Static):
             else:
                 content.append("📡", style="dim")
 
+        # Web server status
+        web_running = is_web_server_running(self.tmux_session)
+        if web_running:
+            content.append(" │ ", style="dim")
+            url = get_web_server_url(self.tmux_session)
+            content.append("🌐", style="green")
+            if url:
+                # Just show port
+                port = url.split(":")[-1] if url else ""
+                content.append(f":{port}", style="cyan")
+
         return content
 
 
@@ -226,9 +266,10 @@ class StatusTimeline(Static):
     MIN_TIMELINE = 20     # Minimum timeline width
     DEFAULT_TIMELINE = 60 # Fallback if can't detect width
 
-    def __init__(self, sessions: list, *args, **kwargs):
+    def __init__(self, sessions: list, tmux_session: str = "agents", *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.sessions = sessions
+        self.tmux_session = tmux_session
         self._presence_history = []
         self._agent_histories = {}
 
@@ -255,8 +296,9 @@ class StatusTimeline(Static):
         # Get agent names from sessions
         agent_names = [s.name for s in sessions]
 
-        # Read all agent history and group by agent
-        all_history = read_agent_status_history(hours=self.TIMELINE_HOURS)
+        # Read agent history from session-specific file and group by agent
+        history_path = get_agent_history_path(self.tmux_session)
+        all_history = read_agent_status_history(hours=self.TIMELINE_HOURS, history_file=history_path)
         for ts, agent, status, activity in all_history:
             if agent not in self._agent_histories:
                 self._agent_histories[agent] = []
@@ -328,6 +370,10 @@ class StatusTimeline(Static):
                     content.append(char, style=color)
                 else:
                     content.append("─", style="dim")
+        elif not MACOS_APIS_AVAILABLE:
+            # Show install instructions when presence deps not installed (macOS only)
+            msg = "macOS only - pip install overcode[presence]"
+            content.append(msg[:width], style="dim italic")
         else:
             content.append("─" * width, style="dim")
         content.append("\n")
@@ -449,10 +495,11 @@ class HelpOverlay(Static):
 ║  ────────────────────────────────────────────────────────────────────────────║
 ║  [       Start supervisor        ]       Stop supervisor                     ║
 ║  \\      Restart monitor         d       Toggle daemon log panel             ║
+║  w       Toggle web dashboard (analytics server)                             ║
 ║                                                                              ║
 ║  SUMMARY DETAIL LEVELS (s key)                                               ║
 ║  ────────────────────────────────────────────────────────────────────────────║
-║  low     Name, tokens, git changes (Δn files), mode, steers, standing orders ║
+║  low     Name, tokens, ctx% (context usage), git Δ, mode, steers, orders     ║
 ║  med     + uptime, running time, stalled time, latency                       ║
 ║  full    + repo:branch, % active, git diff details (+ins -del)               ║
 ║                                                                              ║
@@ -615,6 +662,8 @@ class SessionSummary(Static, can_focus=True):
         self.pane_content: List[str] = []  # Cached pane content
         self.claude_stats: Optional[ClaudeSessionStats] = None  # Token/interaction stats
         self.git_diff_stats: Optional[tuple] = None  # (files, insertions, deletions)
+        # Track if this is a stalled agent that hasn't been visited yet
+        self.is_unvisited_stalled: bool = False
         # Start with expanded class since expanded=True by default
         self.add_class("expanded")
 
@@ -623,6 +672,22 @@ class SessionSummary(Static, can_focus=True):
         self.expanded = not self.expanded
         # Notify parent app to save state
         self.post_message(self.ExpandedChanged(self.session.id, self.expanded))
+        # Mark as visited if this is an unvisited stalled agent
+        if self.is_unvisited_stalled:
+            self.post_message(self.StalledAgentVisited(self.session.id))
+
+    def on_focus(self) -> None:
+        """Handle focus event - mark stalled agent as visited and update selection"""
+        if self.is_unvisited_stalled:
+            self.post_message(self.StalledAgentVisited(self.session.id))
+        # Notify app to update selection highlighting
+        self.post_message(self.SessionSelected(self.session.id))
+
+    class SessionSelected(events.Message):
+        """Message sent when a session is selected/focused"""
+        def __init__(self, session_id: str):
+            super().__init__()
+            self.session_id = session_id
 
     class ExpandedChanged(events.Message):
         """Message sent when expanded state changes"""
@@ -631,6 +696,12 @@ class SessionSummary(Static, can_focus=True):
             self.session_id = session_id
             self.expanded = expanded
 
+    class StalledAgentVisited(events.Message):
+        """Message sent when user visits a stalled agent (focus or click)"""
+        def __init__(self, session_id: str):
+            super().__init__()
+            self.session_id = session_id
+
     def watch_expanded(self, expanded: bool) -> None:
         """Called when expanded state changes"""
         # Toggle CSS class for proper height
@@ -691,7 +762,11 @@ class SessionSummary(Static, can_focus=True):
         # Update detected status for display
         # NOTE: Time tracking removed - Monitor Daemon is the single source of truth
         # The session.stats values are read from what Monitor Daemon has persisted
-        self.detected_status = status
+        # If session is asleep, keep the asleep status instead of the detected status
+        if self.session.is_asleep:
+            self.detected_status = "asleep"
+        else:
+            self.detected_status = status
 
         # Use pre-fetched claude stats (no file I/O on main thread)
         if claude_stats is not None:
@@ -753,6 +828,12 @@ class SessionSummary(Static, can_focus=True):
         # Always show: status symbol, time in state, expand icon, agent name
         content.append(f"{status_symbol} ", style=status_color)
 
+        # Show 🔔 indicator for unvisited stalled agents (needs attention)
+        if self.is_unvisited_stalled:
+            content.append("🔔", style=f"bold blink red{bg}")
+        else:
+            content.append("  ", style=f"dim{bg}")  # Maintain alignment
+
         # Time in current state (directly after status light)
         if stats.state_since:
             try:
@@ -791,27 +872,36 @@ class SessionSummary(Static, can_focus=True):
                 content.append(f" {pct:>3.0f}%", style=f"bold green{bg}" if pct >= 50 else f"bold red{bg}")
 
         # Always show: token usage (from Claude Code)
+        # ALIGNMENT: context indicator is always 7 chars " c@NNN%" (or placeholder)
         if self.claude_stats is not None:
-            content.append(f" {format_tokens(self.claude_stats.total_tokens):>6}", style=f"bold orange1{bg}")
+            content.append(f" Σ{format_tokens(self.claude_stats.total_tokens):>6}", style=f"bold orange1{bg}")
+            # Show current context window usage as percentage (assuming 200K max)
+            if self.claude_stats.current_context_tokens > 0:
+                max_context = 200_000  # Claude models have 200K context window
+                ctx_pct = min(100, self.claude_stats.current_context_tokens / max_context * 100)
+                content.append(f" c@{ctx_pct:>3.0f}%", style=f"bold orange1{bg}")
+            else:
+                content.append(" c@  -%", style=f"dim orange1{bg}")
         else:
-            content.append("      -", style=f"dim orange1{bg}")
+            content.append("      - c@  -%", style=f"dim orange1{bg}")
 
         # Git diff stats (outstanding changes since last commit)
-        # ALIGNMENT: Use fixed widths - low/med: 4 chars "Δnn ", full: 15 chars "Δnn +nnnn -nnn"
+        # ALIGNMENT: Use fixed widths - low/med: 4 chars "Δnn ", full: 16 chars "Δnn +nnnn -nnnn"
+        # Large line counts are shortened: 173242 -> "173K", 1234567 -> "1.2M"
         if self.git_diff_stats:
             files, ins, dels = self.git_diff_stats
             if self.summary_detail == "full":
                 # Full: show files and lines with fixed widths
                 content.append(f" Δ{files:>2}", style=f"bold magenta{bg}")
-                content.append(f" +{ins:>4}", style=f"bold green{bg}")
-                content.append(f" -{dels:>3}", style=f"bold red{bg}")
+                content.append(f" +{format_line_count(ins):>4}", style=f"bold green{bg}")
+                content.append(f" -{format_line_count(dels):>4}", style=f"bold red{bg}")
             else:
                 # Compact: just files changed (fixed 4 char width)
                 content.append(f" Δ{files:>2}", style=f"bold magenta{bg}" if files > 0 else f"dim{bg}")
         else:
             # Placeholder matching width for alignment
             if self.summary_detail == "full":
-                content.append("  Δ-  +   -  -", style=f"dim{bg}")
+                content.append("  Δ-  +   -  -  ", style=f"dim{bg}")
             else:
                 content.append("  Δ-", style=f"dim{bg}")
 
@@ -936,19 +1026,27 @@ class PreviewPane(Static):
 
     def render(self) -> Text:
         content = Text()
-        # Header with session name
+        # Use widget width for layout, with sensible fallback
+        pane_width = self.size.width if self.size.width > 0 else 80
+
+        # Header with session name - pad to full pane width
         header = f"─── {self.session_name} " if self.session_name else "─── Preview "
         content.append(header, style="bold cyan")
-        content.append("─" * max(0, 60 - len(header)), style="dim")
+        content.append("─" * max(0, pane_width - len(header)), style="dim")
         content.append("\n")
 
         if not self.content_lines:
             content.append("(no output)", style="dim italic")
         else:
-            # Show last 30 lines of output - plain text, no decoration
-            for line in self.content_lines[-30:]:
-                # Truncate long lines
-                display_line = line[:200] if len(line) > 200 else line
+            # Calculate available lines based on widget height
+            # Reserve 2 lines for header and some padding
+            available_lines = max(10, self.size.height - 2) if self.size.height > 0 else 30
+            # Show last N lines of output - plain text, no decoration
+            # Truncate lines to pane width to match tmux display
+            max_line_len = max(pane_width - 1, 40)  # Leave room for newline, minimum 40
+            for line in self.content_lines[-available_lines:]:
+                # Truncate long lines to pane width
+                display_line = line[:max_line_len] if len(line) > max_line_len else line
                 content.append(display_line + "\n")
 
         return content
@@ -1332,6 +1430,12 @@ class SupervisorTUI(App):
         text-style: bold;
     }
 
+    /* .selected class preserves highlight when app loses focus */
+    SessionSummary.selected {
+        background: #2d4a5a;
+        text-style: bold;
+    }
+
     #help-text {
         dock: bottom;
         height: 1;
@@ -1489,6 +1593,12 @@ class SupervisorTUI(App):
         ("5", "send_5_to_focused", "Send 5"),
         # Copy mode - disable mouse capture for native terminal selection
         ("y", "toggle_copy_mode", "Copy mode"),
+        # Tmux sync - sync navigation to external tmux pane
+        ("p", "toggle_tmux_sync", "Pane sync"),
+        # Web server toggle
+        ("w", "toggle_web_server", "Web dashboard"),
+        # Sleep mode toggle - mark agent as paused (excluded from stats)
+        ("z", "toggle_sleep", "Sleep mode"),
     ]
 
     # Detail level cycles through 5, 10, 20, 50 lines
@@ -1498,6 +1608,7 @@ class SupervisorTUI(App):
 
     sessions: reactive[List[Session]] = reactive(list)
     view_mode: reactive[str] = reactive("tree")  # "tree" or "list_preview"
+    tmux_sync: reactive[bool] = reactive(False)  # sync navigation to external tmux pane
 
     def __init__(self, tmux_session: str = "agents", diagnostics: bool = False):
         super().__init__()
@@ -1530,6 +1641,8 @@ class SupervisorTUI(App):
 
         # Track focused session for navigation
         self.focused_session_index = 0
+        # Track previous status of each session for detecting transitions to stalled state
+        self._previous_statuses: dict[str, str] = {}
         # Session cache to avoid disk I/O on every status update (250ms interval)
         self._sessions_cache: dict[str, Session] = {}
         self._sessions_cache_time: float = 0
@@ -1538,19 +1651,25 @@ class SupervisorTUI(App):
         self._status_update_in_progress = False
         # Track if we've warned about multiple daemons (to avoid spam)
         self._multiple_daemon_warning_shown = False
+        # Pending kill confirmation (session name, timestamp)
+        self._pending_kill: tuple[str, float] | None = None
+        # Tmux interface for sync operations
+        self._tmux = RealTmux()
+        # Initialize tmux_sync from preferences
+        self.tmux_sync = self._prefs.tmux_sync
 
     def compose(self) -> ComposeResult:
         """Create child widgets"""
         yield Header(show_clock=True)
-        yield DaemonStatusBar(tmux_session=self.tmux_session, id="daemon-status")
-        yield StatusTimeline([], id="timeline")
+        yield DaemonStatusBar(tmux_session=self.tmux_session, session_manager=self.session_manager, id="daemon-status")
+        yield StatusTimeline([], tmux_session=self.tmux_session, id="timeline")
         yield DaemonPanel(tmux_session=self.tmux_session, id="daemon-panel")
         yield ScrollableContainer(id="sessions-container")
         yield PreviewPane(id="preview-pane")
         yield CommandBar(id="command-bar")
         yield HelpOverlay(id="help-overlay")
         yield Static(
-            "h:Help | q:Quit | j/k:Nav | i:Send | n:New | x:Kill | space | m:Mode | d:Daemon | t:Timeline | v:Lines",
+            "h:Help | q:Quit | j/k:Nav | i:Send | n:New | x:Kill | space | m:Mode | p:Sync | d:Daemon | t:Timeline",
             id="help-text"
         )
 
@@ -1624,7 +1743,7 @@ class SupervisorTUI(App):
             pass
 
         # Check for multiple daemon processes (potential time tracking bug)
-        daemon_count = count_daemon_processes("monitor_daemon")
+        daemon_count = count_daemon_processes("monitor_daemon", session=self.tmux_session)
         if daemon_count > 1 and not self._multiple_daemon_warning_shown:
             self._multiple_daemon_warning_shown = True
             self.notify(
@@ -1802,6 +1921,8 @@ class SupervisorTUI(App):
         All data has been pre-fetched in background - this just updates widget state.
         No file I/O happens here.
         """
+        prefs_changed = False
+
         for widget in self.query(SessionSummary):
             session_id = widget.session.id
 
@@ -1814,9 +1935,31 @@ class SupervisorTUI(App):
                 status, activity, content = status_results[session_id]
                 claude_stats = stats_results.get(session_id)
                 git_diff = git_diff_results.get(session_id)
+
+                # Detect transitions TO stalled state (waiting_user)
+                prev_status = self._previous_statuses.get(session_id)
+                if status == STATUS_WAITING_USER and prev_status != STATUS_WAITING_USER:
+                    # Agent just became stalled - mark as unvisited
+                    self._prefs.visited_stalled_agents.discard(session_id)
+                    prefs_changed = True
+
+                # Update previous status for next round
+                self._previous_statuses[session_id] = status
+
+                # Update widget's unvisited state
+                is_unvisited_stalled = (
+                    status == STATUS_WAITING_USER and
+                    session_id not in self._prefs.visited_stalled_agents
+                )
+                widget.is_unvisited_stalled = is_unvisited_stalled
+
                 widget.apply_status_no_refresh(status, activity, content, claude_stats, git_diff)
                 widget.refresh()  # Refresh each widget to repaint
 
+        # Save preferences if we marked any agents as unvisited
+        if prefs_changed:
+            self._save_prefs()
+
         # Update preview pane if in list_preview mode
         if self.view_mode == "list_preview":
             self._update_preview()
@@ -1942,6 +2085,28 @@ class SupervisorTUI(App):
         """Handle expanded state changes from session widgets"""
         self.expanded_states[message.session_id] = message.expanded
 
+    def on_session_summary_stalled_agent_visited(self, message: SessionSummary.StalledAgentVisited) -> None:
+        """Handle when user visits a stalled agent - mark as visited"""
+        session_id = message.session_id
+        self._prefs.visited_stalled_agents.add(session_id)
+        self._save_prefs()
+
+        # Update the widget's state
+        for widget in self.query(SessionSummary):
+            if widget.session.id == session_id:
+                widget.is_unvisited_stalled = False
+                widget.refresh()
+                break
+
+    def on_session_summary_session_selected(self, message: SessionSummary.SessionSelected) -> None:
+        """Handle session selection - update .selected class to preserve highlight when unfocused"""
+        session_id = message.session_id
+        for widget in self.query(SessionSummary):
+            if widget.session.id == session_id:
+                widget.add_class("selected")
+            else:
+                widget.remove_class("selected")
+
     def action_toggle_focused(self) -> None:
         """Toggle expansion of focused session (only in tree mode)"""
         if self.view_mode == "list_preview":
@@ -1996,9 +2161,11 @@ class SupervisorTUI(App):
         if not widgets:
             return
         self.focused_session_index = (self.focused_session_index + 1) % len(widgets)
-        widgets[self.focused_session_index].focus()
+        target_widget = widgets[self.focused_session_index]
+        target_widget.focus()
         if self.view_mode == "list_preview":
             self._update_preview()
+        self._sync_tmux_window(target_widget)
 
     def action_focus_previous_session(self) -> None:
         """Focus the previous session in the list."""
@@ -2006,9 +2173,11 @@ class SupervisorTUI(App):
         if not widgets:
             return
         self.focused_session_index = (self.focused_session_index - 1) % len(widgets)
-        widgets[self.focused_session_index].focus()
+        target_widget = widgets[self.focused_session_index]
+        target_widget.focus()
         if self.view_mode == "list_preview":
             self._update_preview()
+        self._sync_tmux_window(target_widget)
 
     def action_toggle_view_mode(self) -> None:
         """Toggle between tree and list+preview view modes."""
@@ -2021,6 +2190,39 @@ class SupervisorTUI(App):
         self._prefs.view_mode = self.view_mode
         self._save_prefs()
 
+    def action_toggle_tmux_sync(self) -> None:
+        """Toggle tmux pane sync - syncs navigation to external tmux pane."""
+        self.tmux_sync = not self.tmux_sync
+
+        # Save preference
+        self._prefs.tmux_sync = self.tmux_sync
+        self._save_prefs()
+
+        # Update subtitle to show sync state
+        self._update_subtitle()
+
+        # If enabling, sync to currently focused session immediately
+        if self.tmux_sync:
+            self._sync_tmux_window()
+
+    def _sync_tmux_window(self, widget: Optional["SessionSummary"] = None) -> None:
+        """Sync external tmux pane to show the focused session's window.
+
+        Args:
+            widget: The session widget to sync to. If None, uses self.focused.
+        """
+        if not self.tmux_sync:
+            return
+
+        try:
+            target = widget if widget is not None else self.focused
+            if isinstance(target, SessionSummary):
+                window_index = target.session.tmux_window
+                if window_index is not None:
+                    self._tmux.select_window(self.tmux_session, window_index)
+        except Exception:
+            pass  # Silent fail - don't disrupt navigation
+
     def watch_view_mode(self, view_mode: str) -> None:
         """React to view mode changes."""
         # Update subtitle to show current mode
@@ -2049,10 +2251,11 @@ class SupervisorTUI(App):
     def _update_subtitle(self) -> None:
         """Update the header subtitle to show session and view mode."""
         mode_label = "Tree" if self.view_mode == "tree" else "List+Preview"
+        sync_label = " [Sync]" if self.tmux_sync else ""
         if self.diagnostics:
-            self.sub_title = f"{self.tmux_session} [{mode_label}] [DIAGNOSTICS]"
+            self.sub_title = f"{self.tmux_session} [{mode_label}]{sync_label} [DIAGNOSTICS]"
         else:
-            self.sub_title = f"{self.tmux_session} [{mode_label}]"
+            self.sub_title = f"{self.tmux_session} [{mode_label}]{sync_label}"
 
     def _select_first_agent(self) -> None:
         """Select the first agent for initial preview pane display."""
@@ -2071,9 +2274,9 @@ class SupervisorTUI(App):
         """Update preview pane with focused session's content."""
         try:
             preview = self.query_one("#preview-pane", PreviewPane)
-            focused = self.focused
-            if isinstance(focused, SessionSummary):
-                preview.update_from_widget(focused)
+            widgets = self._get_widgets_in_session_order()
+            if widgets and 0 <= self.focused_session_index < len(widgets):
+                preview.update_from_widget(widgets[self.focused_session_index])
         except NoMatches:
             pass
 
@@ -2340,9 +2543,16 @@ class SupervisorTUI(App):
         The Monitor Daemon handles status tracking, time accumulation,
         stats sync, and user presence detection.
         """
+        # Check PID file first
         if is_monitor_daemon_running(self.tmux_session):
             return  # Already running
 
+        # Also check for running processes (in case PID file is stale or daemon is starting)
+        # This prevents race conditions where multiple TUIs start daemons simultaneously
+        daemon_count = count_daemon_processes("monitor_daemon", session=self.tmux_session)
+        if daemon_count > 0:
+            return  # Daemon process exists, just PID file might be missing/stale
+
         try:
             subprocess.Popen(
                 [sys.executable, "-m", "overcode.monitor_daemon",
@@ -2355,8 +2565,62 @@ class SupervisorTUI(App):
         except (OSError, subprocess.SubprocessError) as e:
             self.notify(f"Failed to start Monitor Daemon: {e}", severity="warning")
 
+    def action_toggle_web_server(self) -> None:
+        """Toggle the web analytics dashboard server on/off."""
+        is_running, msg = toggle_web_server(self.tmux_session)
+
+        if is_running:
+            url = get_web_server_url(self.tmux_session)
+            self.notify(f"Web server: {url}", severity="information")
+            try:
+                panel = self.query_one("#daemon-panel", DaemonPanel)
+                panel.log_lines.append(f">>> Web server started: {url}")
+            except NoMatches:
+                pass
+        else:
+            self.notify(f"Web server: {msg}", severity="information")
+            try:
+                panel = self.query_one("#daemon-panel", DaemonPanel)
+                panel.log_lines.append(f">>> Web server: {msg}")
+            except NoMatches:
+                pass
+
+        self.update_daemon_status()
+
+    def action_toggle_sleep(self) -> None:
+        """Toggle sleep mode for the focused agent.
+
+        Sleep mode marks an agent as 'asleep' (human doesn't want it to do anything).
+        Sleeping agents are excluded from stats calculations.
+        Press z again to wake the agent.
+        """
+        focused = self.focused
+        if not isinstance(focused, SessionSummary):
+            self.notify("No agent focused", severity="warning")
+            return
+
+        session = focused.session
+        new_asleep_state = not session.is_asleep
+
+        # Update the session in the session manager
+        self.session_manager.update_session(session.id, is_asleep=new_asleep_state)
+
+        # Update the local session object
+        session.is_asleep = new_asleep_state
+
+        # Update the widget's display status if sleeping
+        if new_asleep_state:
+            focused.detected_status = "asleep"
+            self.notify(f"Agent '{session.name}' is now asleep (excluded from stats)", severity="information")
+        else:
+            # Wake up - status will be refreshed on next update cycle
+            self.notify(f"Agent '{session.name}' is now awake", severity="information")
+
+        # Force a refresh
+        focused.refresh()
+
     def action_kill_focused(self) -> None:
-        """Kill the currently focused agent."""
+        """Kill the currently focused agent (requires confirmation)."""
         focused = self.focused
         if not isinstance(focused, SessionSummary):
             self.notify("No agent focused", severity="warning")
@@ -2364,7 +2628,30 @@ class SupervisorTUI(App):
 
         session_name = focused.session.name
         session_id = focused.session.id
+        now = time.time()
+
+        # Check if this is a confirmation of a pending kill
+        if self._pending_kill:
+            pending_name, pending_time = self._pending_kill
+            # Confirm if same session and within 3 second window
+            if pending_name == session_name and (now - pending_time) < 3.0:
+                self._pending_kill = None  # Clear pending state
+                self._execute_kill(focused, session_name, session_id)
+                return
+            else:
+                # Different session or expired - start new confirmation
+                self._pending_kill = None
+
+        # First press - request confirmation
+        self._pending_kill = (session_name, now)
+        self.notify(
+            f"Press x again to kill '{session_name}'",
+            severity="warning",
+            timeout=3
+        )
 
+    def _execute_kill(self, focused: "SessionSummary", session_name: str, session_id: str) -> None:
+        """Execute the actual kill operation after confirmation."""
         # Use launcher to kill the session
         launcher = ClaudeLauncher(
             tmux_session=self.tmux_session,