overcode 0.3.5__tar.gz → 0.3.6__tar.gz

{overcode-0.3.5/src/overcode.egg-info → overcode-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overcode
-Version: 0.3.5
+Version: 0.3.6
 Summary: A supervisor for managing multiple Claude Code instances in tmux
 Author: Mike Bond
 Project-URL: Homepage, https://github.com/mkb23/overcode

{overcode-0.3.5 → overcode-0.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "overcode"
-version = "0.3.5"
+version = "0.3.6"
 description = "A supervisor for managing multiple Claude Code instances in tmux"
 authors = [
     {name = "Mike Bond"}

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/config.py

@@ -129,12 +129,20 @@ def get_summarizer_config() -> dict:
     # Resolve the actual API key from the configured env var
     api_key = os.environ.get(api_key_var)
 
+    # Cost cap: default $100, configurable
+    cost_cap = _get_config_value("summarizer.cost_cap")
+    if cost_cap is None:
+        cost_cap = 100.0
+    else:
+        cost_cap = float(cost_cap)
+
     return {
         "api_type": api_type,
         "api_url": api_url,
         "model": model,
         "api_key": api_key,
         "api_key_var": api_key_var,
+        "cost_cap": cost_cap,
     }
 
 

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/data_export.py

@@ -8,6 +8,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Dict, Any
 
+from .config import get_hostname
 from .session_manager import SessionManager
 from .status_history import read_agent_status_history
 from .presence_logger import read_presence_history
@@ -118,6 +119,7 @@ def _session_to_record(session, is_archived: bool) -> Dict[str, Any]:
     return {
         "id": session.id,
         "name": session.name,
+        "hostname": getattr(session, 'source_host', '') or get_hostname(),
         "tmux_session": session.tmux_session,
         "tmux_window": session.tmux_window,
         "start_directory": session.start_directory,
@@ -184,6 +186,7 @@ def _get_sessions_schema():
     return pa.schema([
         ("id", pa.string()),
         ("name", pa.string()),
+        ("hostname", pa.string()),
         ("start_time", pa.string()),
         ("end_time", pa.string()),
         ("is_archived", pa.bool_()),
@@ -201,6 +204,8 @@ def _get_timeline_schema():
         ("timestamp", pa.string()),
         ("agent", pa.string()),
         ("status", pa.string()),
+        ("session_id", pa.string()),
+        ("hostname", pa.string()),
     ])
 
 
@@ -223,11 +228,13 @@ def _build_timeline_records():
     records = []
     history = read_agent_status_history(hours=24.0)
 
-    for ts, agent_name, status, activity in history:
+    for ts, agent_name, status, activity, session_id, hostname in history:
         records.append({
             "timestamp": ts.isoformat() if isinstance(ts, datetime) else str(ts),
             "agent": agent_name,
             "status": status,
+            "session_id": session_id,
+            "hostname": hostname,
         })
 
     return records

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/monitor_daemon.py

@@ -284,6 +284,10 @@ class MonitorDaemon:
             mode=detection_mode,
         )
 
+        # Hostname for history disambiguation
+        from .config import get_hostname
+        self._hostname = get_hostname()
+
         # Presence tracking (graceful degradation)
         self.presence = PresenceComponent(tmux_session=tmux_session)
 
@@ -1112,7 +1116,12 @@ class MonitorDaemon:
             session_states.append(session_state)
 
             # Log status history to session-specific file
-            log_agent_status(session.name, effective_status, activity, history_file=self.history_path)
+            log_agent_status(
+                session.name, effective_status, activity,
+                history_file=self.history_path,
+                session_id=session.id,
+                hostname=self._hostname,
+            )
 
             # Track if any session is not waiting for user
             if status != "waiting_user":

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/monitor_daemon_core.py

@@ -104,39 +104,8 @@ def calculate_time_accumulation(
     )
 
 
-def calculate_cost_estimate(
-    input_tokens: int,
-    output_tokens: int,
-    cache_creation_tokens: int = 0,
-    cache_read_tokens: int = 0,
-    price_input: float = 3.0,
-    price_output: float = 15.0,
-    price_cache_write: float = 3.75,
-    price_cache_read: float = 0.30,
-) -> 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: Sonnet)
-        price_output: Price per million output tokens (default: Sonnet)
-        price_cache_write: Price per million cache write tokens (default: Sonnet)
-        price_cache_read: Price per million cache read tokens (default: Sonnet)
-
-    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
-    )
+# Re-exported from pricing module for backward compatibility
+from .pricing import calculate_cost_estimate  # noqa: F401
 
 
 def calculate_total_tokens(

overcode-0.3.6/src/overcode/pricing.py

@@ -0,0 +1,106 @@
+"""
+Standalone pricing module for token cost estimation.
+
+Provides model pricing tables and cost calculation for both Claude and
+third-party models (OpenAI, etc.) used across the codebase — agent sessions
+and the AI summariser.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelPricing:
+    """Per-million-token pricing for a model."""
+    input: float
+    output: float
+    cache_write: float = 0.0
+    cache_read: float = 0.0
+
+
+# Built-in pricing for known model families.
+# Keys are checked as substrings against model names, so "opus" matches
+# "claude-opus-4-6", "gpt-4o-mini" matches "gpt-4o-mini-2024-07-18", etc.
+MODEL_PRICING: dict[str, ModelPricing] = {
+    # Claude models
+    "opus":   ModelPricing(input=15.0, output=75.0, cache_write=18.75, cache_read=1.50),
+    "sonnet": ModelPricing(input=3.0,  output=15.0, cache_write=3.75,  cache_read=0.30),
+    "haiku":  ModelPricing(input=0.80, output=4.0,  cache_write=1.0,   cache_read=0.08),
+    # OpenAI models (commonly used for summariser)
+    "gpt-4o-mini": ModelPricing(input=0.15, output=0.60),
+    "gpt-4o":      ModelPricing(input=2.50, output=10.0),
+    "gpt-4-turbo": ModelPricing(input=10.0, output=30.0),
+    "gpt-3.5":     ModelPricing(input=0.50, output=1.50),
+}
+
+
+def lookup_pricing(model: str) -> ModelPricing:
+    """Look up pricing for a model name by substring match.
+
+    Args:
+        model: Model name (e.g. "gpt-4o-mini", "claude-haiku-4-5-20250929")
+
+    Returns:
+        ModelPricing for the model family, or a zero-cost fallback if unknown.
+    """
+    model_lower = model.lower()
+    # Try longer keys first to avoid "gpt-4o" matching before "gpt-4o-mini"
+    for key in sorted(MODEL_PRICING, key=len, reverse=True):
+        if key in model_lower:
+            return MODEL_PRICING[key]
+    return ModelPricing(input=0.0, output=0.0)
+
+
+def calculate_cost_estimate(
+    input_tokens: int,
+    output_tokens: int,
+    cache_creation_tokens: int = 0,
+    cache_read_tokens: int = 0,
+    price_input: float = 3.0,
+    price_output: float = 15.0,
+    price_cache_write: float = 3.75,
+    price_cache_read: float = 0.30,
+) -> 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: Sonnet)
+        price_output: Price per million output tokens (default: Sonnet)
+        price_cache_write: Price per million cache write tokens (default: Sonnet)
+        price_cache_read: Price per million cache read tokens (default: Sonnet)
+
+    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 estimate_cost(model: str, input_tokens: int, output_tokens: int) -> float:
+    """Convenience: estimate cost for a model from input/output tokens.
+
+    Args:
+        model: Model name (e.g. "gpt-4o-mini")
+        input_tokens: Number of input tokens
+        output_tokens: Number of output tokens
+
+    Returns:
+        Estimated cost in USD
+    """
+    pricing = lookup_pricing(model)
+    return calculate_cost_estimate(
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        price_input=pricing.input,
+        price_output=pricing.output,
+    )

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/settings.py

@@ -205,23 +205,8 @@ TUI = TUISettings()
 # Config File Loading
 # =============================================================================
 
-@dataclass
-class ModelPricing:
-    """Per-million-token pricing for a model."""
-    input: float
-    output: float
-    cache_write: float
-    cache_read: float
-
-
-# Built-in pricing for known Claude model families.
-# Keys are checked as prefixes against model names, so "opus" matches
-# "opus", "claude-opus-4-6", etc.  Order matters: longer prefixes first.
-MODEL_PRICING: dict[str, ModelPricing] = {
-    "opus":   ModelPricing(input=15.0, output=75.0, cache_write=18.75, cache_read=1.50),
-    "sonnet": ModelPricing(input=3.0,  output=15.0, cache_write=3.75,  cache_read=0.30),
-    "haiku":  ModelPricing(input=0.80, output=4.0,  cache_write=1.0,   cache_read=0.08),
-}
+# Re-exported from pricing module for backward compatibility
+from .pricing import ModelPricing, MODEL_PRICING  # noqa: F401
 
 
 def get_model_pricing(model: str | None, fallback: "UserConfig") -> ModelPricing:

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/sister_poller.py

@@ -152,6 +152,7 @@ class SisterPoller:
             return {}
 
         result: Dict[str, List[Tuple[datetime, str]]] = {}
+        host = sister.name
         for agent_name, entries in data.get("agents", {}).items():
             pairs: List[Tuple[datetime, str]] = []
             for entry in entries:
@@ -161,7 +162,8 @@ class SisterPoller:
                 except (KeyError, ValueError):
                     continue
             if pairs:
-                result[agent_name] = pairs
+                # Prefix with hostname for disambiguation across sisters
+                result[f"{host}/{agent_name}"] = pairs
         return result
 
     def _poll_sister(self, sister: SisterState) -> List[Session]:

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/status_history.py

@@ -17,7 +17,9 @@ def log_agent_status(
     agent_name: str,
     status: str,
     activity: str = "",
-    history_file: Optional[Path] = None
+    history_file: Optional[Path] = None,
+    session_id: str = "",
+    hostname: str = "",
 ) -> None:
     """Log agent status to history CSV file.
 
@@ -29,6 +31,8 @@ def log_agent_status(
         status: Current status string
         activity: Optional activity description
         history_file: Optional path override (for testing)
+        session_id: Unique session ID (UUID) for disambiguation
+        hostname: Machine hostname for multi-host disambiguation
     """
     path = history_file or PATHS.agent_history
     path.parent.mkdir(parents=True, exist_ok=True)
@@ -39,12 +43,14 @@ def log_agent_status(
     with open(path, 'a', newline='') as f:
         writer = csv.writer(f)
         if write_header:
-            writer.writerow(['timestamp', 'agent', 'status', 'activity'])
+            writer.writerow(['timestamp', 'agent', 'status', 'activity', 'session_id', 'hostname'])
         writer.writerow([
             datetime.now().isoformat(),
             agent_name,
             status,
-            activity[:100] if activity else ""
+            activity[:100] if activity else "",
+            session_id,
+            hostname,
         ])
 
 
@@ -63,7 +69,7 @@ class StatusHistoryFile:
         self._lock = threading.Lock()
         self._cached_mtime: float = 0.0
         self._cached_size: int = 0
-        self._cached_entries: List[Tuple[datetime, str, str, str]] = []
+        self._cached_entries: List[Tuple[datetime, str, str, str, str, str]] = []
         self._cached_hours: float = 0.0
         self._read_offset: int = 0
 
@@ -71,7 +77,7 @@ class StatusHistoryFile:
         self,
         hours: float = 3.0,
         agent_name: Optional[str] = None,
-    ) -> List[Tuple[datetime, str, str, str]]:
+    ) -> List[Tuple[datetime, str, str, str, str, str]]:
         """Read status history entries, using cache when possible."""
         try:
             stat = self._path.stat()
@@ -177,11 +183,11 @@ class StatusHistoryFile:
         return lo
 
     @staticmethod
-    def _parse_rows(f, start_offset: int) -> List[Tuple[datetime, str, str, str]]:
+    def _parse_rows(f, start_offset: int) -> List[Tuple[datetime, str, str, str, str, str]]:
         """Parse CSV rows from start_offset to end of file."""
         f.seek(start_offset)
         data = f.read().decode('utf-8', errors='replace')
-        entries: List[Tuple[datetime, str, str, str]] = []
+        entries: List[Tuple[datetime, str, str, str, str, str]] = []
         for row in csv.reader(data.splitlines()):
             if len(row) < 3:
                 continue
@@ -189,7 +195,14 @@ class StatusHistoryFile:
                 continue
             try:
                 ts = datetime.fromisoformat(row[0])
-                entries.append((ts, row[1], row[2], row[3] if len(row) > 3 else ''))
+                entries.append((
+                    ts,
+                    row[1],                             # agent
+                    row[2],                             # status
+                    row[3] if len(row) > 3 else '',     # activity
+                    row[4] if len(row) > 4 else '',     # session_id
+                    row[5] if len(row) > 5 else '',     # hostname
+                ))
             except (ValueError, IndexError):
                 continue
         return entries
@@ -222,7 +235,7 @@ def read_agent_status_history(
     hours: float = 3.0,
     agent_name: Optional[str] = None,
     history_file: Optional[Path] = None
-) -> List[Tuple[datetime, str, str, str]]:
+) -> List[Tuple[datetime, str, str, str, str, str]]:
     """Read agent status history from CSV file.
 
     Args:
@@ -231,7 +244,9 @@ def read_agent_status_history(
         history_file: Optional path override (for testing)
 
     Returns:
-        List of (timestamp, agent, status, activity) tuples, oldest first
+        List of (timestamp, agent, status, activity, session_id, hostname)
+        tuples, oldest first. session_id and hostname may be empty for
+        rows written before v0.3.6.
     """
     path = history_file or PATHS.agent_history
     return _get_or_create_reader(path).read(hours, agent_name)
@@ -253,7 +268,7 @@ def get_agent_timeline(
         List of (timestamp, status) tuples for the agent
     """
     history = read_agent_status_history(hours, agent_name, history_file)
-    return [(ts, status) for ts, _, status, _ in history]
+    return [(ts, status) for ts, _, status, _, _, _ in history]
 
 
 def clear_old_history(

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/summarizer_client.py

@@ -102,6 +102,9 @@ class SummarizerClient:
         self.api_key = api_key or config["api_key"]
         self.api_type = config.get("api_type", "openai")
         self._available = bool(self.api_key)
+        # Token usage from the most recent API call (for cost tracking)
+        self.last_input_tokens: int = 0
+        self.last_output_tokens: int = 0
 
     @property
     def available(self) -> bool:
@@ -150,6 +153,9 @@ class SummarizerClient:
 
     def _call_anthropic(self, prompt: str, max_tokens: int) -> Optional[str]:
         """Call the Anthropic Messages API."""
+        self.last_input_tokens = 0
+        self.last_output_tokens = 0
+
         payload = json.dumps({
             "model": self.model,
             "max_tokens": max_tokens,
@@ -172,6 +178,9 @@ class SummarizerClient:
                 if response.status == 200:
                     result = json.loads(response.read().decode("utf-8"))
                     content = result["content"][0]["text"]
+                    usage = result.get("usage", {})
+                    self.last_input_tokens = usage.get("input_tokens", 0)
+                    self.last_output_tokens = usage.get("output_tokens", 0)
                     return content.strip()
                 else:
                     logger.warning(f"Summarizer API error: {response.status}")
@@ -188,6 +197,9 @@ class SummarizerClient:
 
     def _call_openai(self, prompt: str, max_tokens: int) -> Optional[str]:
         """Call the OpenAI Chat Completions API."""
+        self.last_input_tokens = 0
+        self.last_output_tokens = 0
+
         payload = json.dumps({
             "model": self.model,
             "max_tokens": max_tokens,
@@ -210,6 +222,9 @@ class SummarizerClient:
                 if response.status == 200:
                     result = json.loads(response.read().decode("utf-8"))
                     content = result["choices"][0]["message"]["content"]
+                    usage = result.get("usage", {})
+                    self.last_input_tokens = usage.get("prompt_tokens", 0)
+                    self.last_output_tokens = usage.get("completion_tokens", 0)
                     return content.strip()
                 else:
                     logger.warning(

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/summarizer_component.py

@@ -46,6 +46,8 @@ class SummarizerConfig:
     context_interval: float = 15.0  # Seconds between context summary updates (less frequent)
     lines: int = DEFAULT_CAPTURE_LINES  # Pane lines to capture
     max_tokens: int = 150  # Max response tokens
+    idle_timeout: float = 300.0  # Auto-disable after 5 minutes of no TUI keypresses
+    cost_cap: float = 100.0  # Per-TUI-launch cost cap in USD; requires restart to reset
 
 
 class SummarizerComponent:
@@ -95,6 +97,8 @@ class SummarizerComponent:
         # Stats
         self.total_calls = 0
         self.total_tokens = 0
+        self.total_cost_usd: float = 0.0
+        self.cost_cap_hit: bool = False
 
     @property
     def available(self) -> bool:
@@ -212,6 +216,7 @@ class SummarizerComponent:
             )
 
             self.total_calls += 1
+            self._accumulate_cost()
 
             if result and result.strip().upper() != "UNCHANGED":
                 summary.text = result.strip()
@@ -238,6 +243,7 @@ class SummarizerComponent:
             )
 
             self.total_calls += 1
+            self._accumulate_cost()
 
             if result and result.strip().upper() != "UNCHANGED":
                 summary.context = result.strip()
@@ -249,6 +255,17 @@ class SummarizerComponent:
         except Exception as e:
             logger.warning(f"Context summary error for {session.name}: {e}")
 
+    def _accumulate_cost(self) -> None:
+        """Accumulate cost from the most recent API call."""
+        if not self._client:
+            return
+        input_tokens = getattr(self._client, 'last_input_tokens', 0)
+        output_tokens = getattr(self._client, 'last_output_tokens', 0)
+        model = getattr(self._client, 'model', None)
+        if (input_tokens or output_tokens) and isinstance(model, str):
+            from .pricing import estimate_cost
+            self.total_cost_usd += estimate_cost(model, input_tokens, output_tokens)
+
     def _capture_pane(self, window: str) -> Optional[str]:
         """Capture pane content for summarization.
 

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/tui.py

@@ -341,9 +341,11 @@ class SupervisorTUI(
         self._usage_monitor = UsageMonitor()
 
         # AI Summarizer - owned by TUI, not daemon (zero cost when TUI closed)
+        from .config import get_summarizer_config as _get_sum_cfg
+        _sum_cfg = _get_sum_cfg()
         self._summarizer = SummarizerComponent(
             tmux_session=tmux_session,
-            config=SummarizerConfig(enabled=False),  # Disabled by default
+            config=SummarizerConfig(enabled=False, cost_cap=_sum_cfg.get("cost_cap", 100.0)),
         )
         self._summaries: dict[str, AgentSummary] = {}
 
@@ -1554,12 +1556,45 @@ class SupervisorTUI(
     def _update_summaries_async(self) -> None:
         """Background thread for AI summarization.
 
-        Only runs if summarizer is enabled. Updates are applied to widgets
-        via call_from_thread.
+        Only runs if summarizer is enabled. Auto-pauses after idle timeout
+        (no TUI keypresses) to prevent runaway API costs.
         """
         if not self._summarizer.enabled:
             return
 
+        # Auto-pause if TUI has been idle beyond the configured timeout
+        if self._last_keypress > 0:
+            idle_secs = time.monotonic() - self._last_keypress
+            if idle_secs >= self._summarizer.config.idle_timeout:
+                self._summarizer_idle_paused = True
+                self._summarizer.config.enabled = False
+                if self._summarizer._client:
+                    self._summarizer._client.close()
+                    self._summarizer._client = None
+                idle_mins = int(idle_secs // 60)
+                self.call_from_thread(
+                    self.notify,
+                    f"AI Summarizer paused ({idle_mins}m idle — press any key to resume)",
+                    severity="warning",
+                )
+                return
+
+        # Hard-halt if cost cap exceeded (requires TUI restart to reset)
+        cap = self._summarizer.config.cost_cap
+        if cap > 0 and self._summarizer.total_cost_usd >= cap:
+            self._summarizer.cost_cap_hit = True
+            self._summarizer.config.enabled = False
+            if self._summarizer._client:
+                self._summarizer._client.close()
+                self._summarizer._client = None
+            from .tui_helpers import format_cost
+            self.call_from_thread(
+                self.notify,
+                f"AI Summarizer HALTED — cost cap {format_cost(cap)} reached. Restart TUI to reset.",
+                severity="error",
+            )
+            return
+
         # Get fresh session list (filtered to this tmux session)
         all_sessions = self.session_manager.list_sessions()
         sessions = [s for s in all_sessions if s.tmux_session == self.tmux_session]
@@ -3402,6 +3437,9 @@ class SupervisorTUI(
 
     # Throttle TUI heartbeat writes to once per 5 seconds
     _last_heartbeat_write: float = 0.0
+    # Track last keypress for summariser idle auto-shutoff
+    _last_keypress: float = 0.0
+    _summarizer_idle_paused: bool = False
 
     def on_key(self, event: events.Key) -> None:
         """Signal activity to daemon on any keypress."""
@@ -3409,10 +3447,21 @@ class SupervisorTUI(
 
         # Write TUI heartbeat (throttled to every 5s)
         now = time.monotonic()
+        self._last_keypress = now
         if now - self._last_heartbeat_write >= 5.0:
             self._last_heartbeat_write = now
             write_tui_heartbeat(self.tmux_session)
 
+        # Re-enable summariser if it was auto-paused due to idle (not if cost cap hit)
+        if self._summarizer_idle_paused and not self._summarizer.cost_cap_hit:
+            self._summarizer_idle_paused = False
+            self._summarizer.config.enabled = True
+            if not self._summarizer._client:
+                from .summarizer_client import SummarizerClient
+                self._summarizer._client = SummarizerClient()
+            self.notify("AI Summarizer resumed (activity detected)", severity="information")
+            self._update_summaries_async()
+
         # Auto-recover if focus was lost or landed on a non-interactive widget
         # (e.g., clicking the terminal window focuses the preview pane)
         if self._should_recover_focus():

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/tui_actions/daemon.py

@@ -114,6 +114,29 @@ class DaemonActionsMixin:
             self.notify("AI Summarizer unavailable - set OPENAI_API_KEY", severity="warning")
             return
 
+        # Block re-enable if cost cap was hit (requires TUI restart)
+        if self._summarizer.cost_cap_hit and not self._summarizer.config.enabled:
+            from ..tui_helpers import format_cost
+            cap = self._summarizer.config.cost_cap
+            self.notify(
+                f"AI Summarizer HALTED — cost cap {format_cost(cap)} reached. Restart TUI to reset.",
+                severity="error",
+            )
+            return
+
+        # Block enable if model has no pricing data
+        if not self._summarizer.config.enabled:
+            from ..pricing import lookup_pricing
+            from ..config import get_summarizer_config
+            model = get_summarizer_config()["model"]
+            pricing = lookup_pricing(model)
+            if pricing.input == 0.0 and pricing.output == 0.0:
+                self.notify(
+                    f"AI Summarizer blocked — no cost data for model '{model}'",
+                    severity="error",
+                )
+                return
+
         # Toggle the state
         self._summarizer.config.enabled = not self._summarizer.config.enabled
 

{overcode-0.3.5 → overcode-0.3.6}/src/overcode/tui_logic.py

@@ -424,7 +424,7 @@ def calculate_spin_stats(
 
 
 def calculate_mean_spin_from_history(
-    history: List[Tuple[datetime, str, str, str]],
+    history: list,
     agent_names: List[str],
     baseline_minutes: int,
     now: Optional[datetime] = None,
@@ -456,7 +456,7 @@ def calculate_mean_spin_from_history(
     # Filter to window and active agents only
     window_history = [
         (ts, agent, status)
-        for ts, agent, status, _ in history
+        for ts, agent, status, *_ in history
         if cutoff <= ts <= now and agent in agent_names
     ]