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

overcode/summarizer_client.py

@@ -2,54 +2,93 @@
 OpenAI API client for agent summarization.
 
 Uses GPT-4o-mini for cost-effective, high-frequency summaries.
+
+Configuration via ~/.overcode/config.yaml (preferred) or environment variables (fallback):
+
+Config file format:
+    summarizer:
+      api_url: https://api.openai.com/v1/chat/completions
+      model: gpt-4o-mini
+      api_key_var: OPENAI_API_KEY
+
+Environment variable fallbacks:
+    OVERCODE_SUMMARIZER_API_URL
+    OVERCODE_SUMMARIZER_MODEL
+    OVERCODE_SUMMARIZER_API_KEY_VAR
 """
 
 import json
 import logging
-import os
 import urllib.error
 import urllib.request
 from typing import Optional
 
-logger = logging.getLogger(__name__)
+from .config import get_summarizer_config
 
-MODEL = "gpt-4o-mini"
-API_URL = "https://api.openai.com/v1/chat/completions"
+logger = logging.getLogger(__name__)
 
-# Anti-oscillation prompt template
-SUMMARIZE_PROMPT = """You are summarizing a Claude Code agent's terminal output.
+# Short summary prompt - focuses on IMMEDIATE ACTION (verb-first, what's happening this second)
+SUMMARIZE_PROMPT_SHORT = """What is the agent doing RIGHT NOW? Answer with the immediate action only.
 
-## Current Terminal Content (last {lines} lines):
+## Terminal (last {lines} lines):
 {pane_content}
 
-## Current Status: {status}
+## Previous:
+{previous_summary}
+
+FORMAT: Start with a verb. Examples:
+- "reading src/auth.py"
+- "running pytest -v"
+- "waiting for approval"
+- "writing migration file"
+- "editing line 45"
 
-## Previous Summary:
+RULES:
+- Verb first, always (reading/writing/running/waiting/editing/fixing)
+- Name the specific file or command if visible
+- Max 40 chars
+- If unchanged: UNCHANGED"""
+
+# Context summary prompt - focuses on THE TASK (noun-first, the feature/bug/goal)
+SUMMARIZE_PROMPT_CONTEXT = """What TASK or FEATURE is being worked on? Not the current action - the goal.
+
+## Terminal (last {lines} lines):
+{pane_content}
+
+## Previous:
 {previous_summary}
 
-## Instructions:
-1. Summarize what the agent has been doing in 1-2 sentences
-2. If not running, explain the halt state (waiting for user input, permission needed, etc.)
-3. IMPORTANT: Only provide a new summary if there's meaningful new information.
-   If the situation is essentially the same as the previous summary, respond with exactly:
-   UNCHANGED
+FORMAT: Describe the task/feature/bug. Examples:
+- "JWT auth migration"
+- "user search pagination"
+- "fix: race condition in queue"
+- "PR #42 review comments"
+- "new settings dark mode"
 
-Keep summaries concise (under 80 words). Focus on:
-- What task/feature is being worked on
-- Current action (reading files, writing code, running tests, etc.)
-- If halted: why and what's needed to continue"""
+RULES:
+- Noun/task first (not a verb like "implementing")
+- Include ticket/PR numbers if mentioned
+- Focus on WHAT is being built/fixed, not HOW
+- Max 60 chars
+- If unchanged: UNCHANGED"""
 
 
 class SummarizerClient:
-    """Client for OpenAI API to generate agent summaries."""
+    """Client for OpenAI-compatible API to generate agent summaries.
+
+    Supports custom API endpoints for corporate gateways via config file or env vars.
+    """
 
     def __init__(self, api_key: Optional[str] = None):
         """Initialize the client.
 
         Args:
-            api_key: OpenAI API key. If None, reads from OPENAI_API_KEY env var.
+            api_key: API key. If None, reads from config file or env var.
         """
-        self.api_key = api_key or os.environ.get("OPENAI_API_KEY")
+        config = get_summarizer_config()
+        self.api_url = config["api_url"]
+        self.model = config["model"]
+        self.api_key = api_key or config["api_key"]
         self._available = bool(self.api_key)
 
     @property
@@ -64,6 +103,7 @@ class SummarizerClient:
         current_status: str,
         lines: int = 200,
         max_tokens: int = 150,
+        mode: str = "short",
     ) -> Optional[str]:
         """Get summary from GPT-4o-mini.
 
@@ -73,6 +113,7 @@ class SummarizerClient:
             current_status: Current agent status (running, waiting_user, etc.)
             lines: Number of lines being summarized (for prompt context)
             max_tokens: Maximum tokens in response
+            mode: "short" for current activity, "context" for wider context
 
         Returns:
             New summary text, "UNCHANGED" if no update needed, or None on error
@@ -80,7 +121,10 @@ class SummarizerClient:
         if not self.available:
             return None
 
-        prompt = SUMMARIZE_PROMPT.format(
+        # Select prompt based on mode
+        prompt_template = SUMMARIZE_PROMPT_CONTEXT if mode == "context" else SUMMARIZE_PROMPT_SHORT
+
+        prompt = prompt_template.format(
             lines=lines,
             pane_content=pane_content,
             status=current_status,
@@ -88,14 +132,14 @@ class SummarizerClient:
         )
 
         payload = json.dumps({
-            "model": MODEL,
+            "model": self.model,
             "max_tokens": max_tokens,
             "temperature": 0.3,  # Low temperature for consistent summaries
             "messages": [{"role": "user", "content": prompt}],
         }).encode("utf-8")
 
         req = urllib.request.Request(
-            API_URL,
+            self.api_url,
             data=payload,
             headers={
                 "Authorization": f"Bearer {self.api_key}",
@@ -132,5 +176,6 @@ class SummarizerClient:
 
     @staticmethod
     def is_available() -> bool:
-        """Check if OPENAI_API_KEY is set in environment."""
-        return bool(os.environ.get("OPENAI_API_KEY"))
+        """Check if API key is available (from config or environment)."""
+        config = get_summarizer_config()
+        return bool(config["api_key"])

overcode/summarizer_component.py

@@ -3,18 +3,17 @@ Summarizer component for generating agent activity summaries.
 
 Uses GPT-4o-mini to summarize what each agent has been doing and
 their current halt state if not running.
+
+Note: The summarizer now lives in the TUI, not the daemon.
+This ensures zero API costs when the TUI is closed (no one would see the summaries anyway).
 """
 
-import json
 import logging
-import os
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from datetime import datetime
-from pathlib import Path
 from typing import Dict, Optional, TYPE_CHECKING
 
 from .summarizer_client import SummarizerClient
-from .settings import get_session_dir
 
 if TYPE_CHECKING:
     from .interfaces import TmuxInterface
@@ -26,17 +25,23 @@ logger = logging.getLogger(__name__)
 class AgentSummary:
     """Summary for a single agent."""
 
+    # Short summary - current activity (~50 chars)
     text: str = ""
     updated_at: Optional[str] = None  # ISO timestamp
     tokens_used: int = 0
 
+    # Context summary - wider context (~80 chars)
+    context: str = ""
+    context_updated_at: Optional[str] = None  # ISO timestamp
+
 
 @dataclass
 class SummarizerConfig:
     """Configuration for the summarizer."""
 
     enabled: bool = False  # Off by default
-    interval: float = 5.0  # Seconds between updates per agent
+    interval: float = 5.0  # Seconds between short summary updates per agent
+    context_interval: float = 15.0  # Seconds between context summary updates (less frequent)
     lines: int = 200  # Pane lines to capture
     max_tokens: int = 150  # Max response tokens
 
@@ -78,8 +83,9 @@ class SummarizerComponent:
         # Per-agent summaries
         self.summaries: Dict[str, AgentSummary] = {}
 
-        # Rate limiting per session
+        # Rate limiting per session (separate for short and context)
         self._last_update: Dict[str, datetime] = {}
+        self._last_context_update: Dict[str, datetime] = {}
 
         # Content hashes for change detection (avoid API calls when nothing changed)
         self._last_content_hash: Dict[str, int] = {}
@@ -88,9 +94,6 @@ class SummarizerComponent:
         self.total_calls = 0
         self.total_tokens = 0
 
-        # Control file path
-        self._control_file = get_session_dir(tmux_session) / "summarizer_control.json"
-
     @property
     def available(self) -> bool:
         """Check if summarizer is available (API key present)."""
@@ -101,36 +104,6 @@ class SummarizerComponent:
         """Check if summarizer is currently enabled."""
         return self.config.enabled and self._client is not None
 
-    def check_control_file(self) -> None:
-        """Check control file for enable/disable commands."""
-        if not self._control_file.exists():
-            return
-
-        try:
-            with open(self._control_file) as f:
-                data = json.load(f)
-
-            should_enable = data.get("enabled", False)
-
-            if should_enable and not self.config.enabled:
-                # Enable requested
-                if SummarizerClient.is_available():
-                    self.config.enabled = True
-                    self._client = SummarizerClient()
-                    logger.info("Summarizer enabled via control file")
-                else:
-                    logger.warning("Summarizer enable requested but OPENAI_API_KEY not set")
-            elif not should_enable and self.config.enabled:
-                # Disable requested
-                self.config.enabled = False
-                if self._client:
-                    self._client.close()
-                    self._client = None
-                logger.info("Summarizer disabled via control file")
-
-        except (json.JSONDecodeError, OSError) as e:
-            logger.warning(f"Error reading summarizer control file: {e}")
-
     def update(self, sessions) -> Dict[str, AgentSummary]:
         """Update summaries for all sessions.
 
@@ -140,9 +113,6 @@ class SummarizerComponent:
         Returns:
             Dict mapping session_id to AgentSummary
         """
-        # Check control file for enable/disable
-        self.check_control_file()
-
         if not self.enabled:
             return self.summaries
 
@@ -152,7 +122,11 @@ class SummarizerComponent:
         return self.summaries
 
     def _update_session(self, session) -> None:
-        """Update summary for a single session.
+        """Update summaries for a single session.
+
+        Generates two types of summaries:
+        - Short: current activity (updated frequently)
+        - Context: wider context (updated less frequently)
 
         Args:
             session: Session object with id, tmux_window, current_status
@@ -163,12 +137,18 @@ class SummarizerComponent:
         session_id = session.id
         now = datetime.now()
 
-        # Rate limiting - don't call API too frequently for same session
-        last_update = self._last_update.get(session_id)
-        if last_update:
-            elapsed = (now - last_update).total_seconds()
-            if elapsed < self.config.interval:
-                return
+        # Check rate limits for each summary type
+        last_short = self._last_update.get(session_id)
+        last_context = self._last_context_update.get(session_id)
+
+        short_elapsed = (now - last_short).total_seconds() if last_short else float('inf')
+        context_elapsed = (now - last_context).total_seconds() if last_context else float('inf')
+
+        need_short = short_elapsed >= self.config.interval
+        need_context = context_elapsed >= self.config.context_interval
+
+        if not need_short and not need_context:
+            return
 
         # Skip terminated sessions
         current_status = getattr(session, 'stats', None)
@@ -184,47 +164,88 @@ class SummarizerComponent:
 
         # Check if content has actually changed (avoid unnecessary API calls)
         content_hash = hash(content)
+        content_changed = True
         if session_id in self._last_content_hash:
             if self._last_content_hash[session_id] == content_hash:
-                # Content hasn't changed - skip API call
-                return
+                content_changed = False
+
+        # If content hasn't changed, skip short summary but still allow context
+        # (context changes less often so we're more lenient)
+        if not content_changed and not need_context:
+            return
 
         self._last_content_hash[session_id] = content_hash
 
-        # Get previous summary for anti-oscillation
+        # Get or create summary object
         prev_summary = self.summaries.get(session_id)
-        prev_text = prev_summary.text if prev_summary else ""
+        if not prev_summary:
+            prev_summary = AgentSummary()
+            self.summaries[session_id] = prev_summary
 
         # Get current detected status
         status = "unknown"
         if current_status:
             status = getattr(current_status, 'current_state', 'unknown')
 
-        # Call API
+        # Update short summary if needed and content changed
+        if need_short and content_changed:
+            self._update_short_summary(session, prev_summary, content, status, now)
+
+        # Update context summary if needed (less frequent, runs even if content same)
+        if need_context:
+            self._update_context_summary(session, prev_summary, content, status, now)
+
+    def _update_short_summary(
+        self, session, summary: AgentSummary, content: str, status: str, now: datetime
+    ) -> None:
+        """Update the short (current activity) summary."""
         try:
             result = self._client.summarize(
                 pane_content=content,
-                previous_summary=prev_text,
+                previous_summary=summary.text,
                 current_status=status,
                 lines=self.config.lines,
-                max_tokens=self.config.max_tokens,
+                max_tokens=50,  # Aggressive limit for terse output
+                mode="short",
             )
 
             self.total_calls += 1
 
             if result and result.strip().upper() != "UNCHANGED":
-                # New summary
-                self.summaries[session_id] = AgentSummary(
-                    text=result.strip(),
-                    updated_at=now.isoformat(),
-                )
-                logger.debug(f"Updated summary for {session.name}: {result[:50]}...")
-            # If "UNCHANGED", keep the old summary
+                summary.text = result.strip()
+                summary.updated_at = now.isoformat()
+                logger.debug(f"Updated short summary for {session.name}: {result[:50]}...")
 
-            self._last_update[session_id] = now
+            self._last_update[session.id] = now
 
         except Exception as e:
-            logger.warning(f"Summarizer error for {session.name}: {e}")
+            logger.warning(f"Short summary error for {session.name}: {e}")
+
+    def _update_context_summary(
+        self, session, summary: AgentSummary, content: str, status: str, now: datetime
+    ) -> None:
+        """Update the context (wider context) summary."""
+        try:
+            result = self._client.summarize(
+                pane_content=content,
+                previous_summary=summary.context,
+                current_status=status,
+                lines=self.config.lines,
+                max_tokens=75,  # Aggressive limit for terse output
+                mode="context",
+            )
+
+            self.total_calls += 1
+
+            if result and result.strip().upper() != "UNCHANGED":
+                summary.context = result.strip()
+                summary.context_updated_at = now.isoformat()
+                logger.debug(f"Updated context summary for {session.name}: {result[:50]}...")
+
+            self._last_context_update[session.id] = now
+
+        except Exception as e:
+            logger.warning(f"Context summary error for {session.name}: {e}")
 
     def _capture_pane(self, window: int) -> Optional[str]:
         """Capture pane content for summarization.
@@ -269,44 +290,3 @@ class SummarizerComponent:
         if self._client:
             self._client.close()
             self._client = None
-
-
-def get_summarizer_control_path(session: str) -> Path:
-    """Get the summarizer control file path for a session."""
-    return get_session_dir(session) / "summarizer_control.json"
-
-
-def set_summarizer_enabled(session: str, enabled: bool) -> None:
-    """Set summarizer enabled state via control file.
-
-    The daemon reads this file each loop and adjusts accordingly.
-
-    Args:
-        session: tmux session name
-        enabled: Whether to enable or disable
-    """
-    control_path = get_summarizer_control_path(session)
-    control_path.parent.mkdir(parents=True, exist_ok=True)
-    with open(control_path, 'w') as f:
-        json.dump({"enabled": enabled}, f)
-
-
-def is_summarizer_enabled(session: str) -> bool:
-    """Check if summarizer is enabled for a session.
-
-    Args:
-        session: tmux session name
-
-    Returns:
-        True if enabled, False otherwise
-    """
-    control_path = get_summarizer_control_path(session)
-    if not control_path.exists():
-        return False
-
-    try:
-        with open(control_path) as f:
-            data = json.load(f)
-        return data.get("enabled", False)
-    except (json.JSONDecodeError, OSError):
-        return False

overcode/supervisor_daemon.py

@@ -16,7 +16,7 @@ Prerequisites:
 Architecture:
     Monitor Daemon (metrics) → monitor_daemon_state.json → Supervisor Daemon (claude)
 
-TODO: Add unit tests (currently 0% coverage)
+Pure business logic is extracted to supervisor_daemon_core.py for testability.
 TODO: Extract _send_prompt_to_window to a shared tmux utilities module
 (duplicated in launcher.py)
 """
@@ -60,6 +60,13 @@ from .status_constants import (
 )
 from .tmux_manager import TmuxManager
 from .history_reader import encode_project_path, read_token_usage_from_session_file
+from .supervisor_daemon_core import (
+    build_daemon_claude_context as _build_daemon_claude_context,
+    filter_non_green_sessions,
+    calculate_daemon_claude_run_seconds,
+    should_launch_daemon_claude,
+    parse_intervention_log_line,
+)
 
 
 @dataclass
@@ -473,14 +480,14 @@ class SupervisorDaemon:
     def _mark_daemon_claude_stopped(self) -> None:
         """Mark daemon claude as stopped and accumulate run time."""
         if self.supervisor_stats.supervisor_claude_running:
-            # Calculate run duration
-            if self.supervisor_stats.supervisor_claude_started_at:
-                try:
-                    started_at = datetime.fromisoformat(self.supervisor_stats.supervisor_claude_started_at)
-                    run_seconds = (datetime.now() - started_at).total_seconds()
-                    self.supervisor_stats.supervisor_claude_total_run_seconds += run_seconds
-                except (ValueError, TypeError):
-                    pass
+            # Calculate total run time using pure function
+            self.supervisor_stats.supervisor_claude_total_run_seconds = (
+                calculate_daemon_claude_run_seconds(
+                    started_at_iso=self.supervisor_stats.supervisor_claude_started_at,
+                    now_iso=datetime.now().isoformat(),
+                    previous_total=self.supervisor_stats.supervisor_claude_total_run_seconds,
+                )
+            )
 
             self.supervisor_stats.supervisor_claude_running = False
             self.supervisor_stats.supervisor_claude_started_at = None
@@ -555,31 +562,18 @@ class SupervisorDaemon:
         non_green_sessions: List[SessionDaemonState]
     ) -> str:
         """Build initial context for daemon claude."""
-        context_parts = []
-
-        context_parts.append("You are the Overcode daemon claude agent.")
-        context_parts.append("Your mission: Make all RED/YELLOW/ORANGE sessions GREEN.")
-        context_parts.append("")
-        context_parts.append(f"TMUX SESSION: {self.tmux_session}")
-        context_parts.append(f"Sessions needing attention: {len(non_green_sessions)}")
-        context_parts.append("")
-
-        for session in non_green_sessions:
-            emoji = get_status_emoji(session.current_status)
-            context_parts.append(f"{emoji} {session.name} (window {session.tmux_window})")
-            if session.standing_instructions:
-                context_parts.append(f"   Autopilot: {session.standing_instructions}")
-            else:
-                context_parts.append(f"   No autopilot instructions set")
-            if session.repo_name:
-                context_parts.append(f"   Repo: {session.repo_name}")
-            context_parts.append("")
-
-        context_parts.append("Read the daemon claude skill for how to control sessions via tmux.")
-        context_parts.append("Start by reading ~/.overcode/sessions/sessions.json to see full state.")
-        context_parts.append("Then check each non-green session and help them make progress.")
-
-        return "\n".join(context_parts)
+        # Convert dataclass objects to dicts for pure function
+        session_dicts = [
+            {
+                "name": s.name,
+                "tmux_window": s.tmux_window,
+                "current_status": s.current_status,
+                "standing_instructions": s.standing_instructions,
+                "repo_name": s.repo_name,
+            }
+            for s in non_green_sessions
+        ]
+        return _build_daemon_claude_context(self.tmux_session, session_dicts)
 
     def _send_prompt_to_window(self, window_index: int, prompt: str) -> bool:
         """Send a large prompt to a tmux window via load-buffer/paste-buffer."""
@@ -678,12 +672,35 @@ class SupervisorDaemon:
         self,
         monitor_state: MonitorDaemonState
     ) -> List[SessionDaemonState]:
-        """Get sessions that are not in running state from monitor daemon state."""
-        return [
-            s for s in monitor_state.sessions
-            if s.current_status != STATUS_RUNNING and s.name != 'daemon_claude'
+        """Get sessions that are not in running state from monitor daemon state.
+
+        Filters out:
+        - Running (green) sessions
+        - The daemon_claude session itself
+        - Asleep sessions (#70)
+        - Sessions with DO_NOTHING standing orders (#70)
+        """
+        # Convert to dicts for pure function
+        session_dicts = [
+            {
+                "name": s.name,
+                "current_status": s.current_status,
+                "is_asleep": s.is_asleep,
+                "standing_instructions": s.standing_instructions,
+                "_session": s,  # Keep reference to original
+            }
+            for s in monitor_state.sessions
         ]
 
+        # Filter using pure function
+        filtered = filter_non_green_sessions(
+            session_dicts,
+            exclude_names=["daemon_claude"],
+        )
+
+        # Return original SessionDaemonState objects
+        return [d["_session"] for d in filtered]
+
     def wait_for_monitor_daemon(self, timeout: int = 30, poll_interval: int = 2) -> bool:
         """Wait for monitor daemon to be running.