overcode 0.1.9__tar.gz → 0.2.0__tar.gz

{overcode-0.1.9/src/overcode.egg-info → overcode-0.2.0}/PKG-INFO

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

{overcode-0.1.9 → overcode-0.2.0}/pyproject.toml

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

{overcode-0.1.9 → overcode-0.2.0}/src/overcode/claude_config.py

@@ -137,3 +137,50 @@ class ClaudeConfigEditor:
                     if cmd.startswith(command_prefix):
                         results.append((event, cmd))
         return results
+
+    # ----- Permission management -----
+
+    def add_permission(self, tool_pattern: str) -> bool:
+        """Add to permissions.allow. Returns True if newly added."""
+        settings = self.load()
+        allow_list = settings.get("permissions", {}).get("allow", [])
+        if tool_pattern in allow_list:
+            return False
+
+        updated = copy.deepcopy(settings)
+        if "permissions" not in updated:
+            updated["permissions"] = {}
+        if "allow" not in updated["permissions"]:
+            updated["permissions"]["allow"] = []
+        updated["permissions"]["allow"].append(tool_pattern)
+        self.save(updated)
+        return True
+
+    def remove_permission(self, tool_pattern: str) -> bool:
+        """Remove from permissions.allow. Returns True if found."""
+        settings = self.load()
+        allow_list = settings.get("permissions", {}).get("allow", [])
+        if tool_pattern not in allow_list:
+            return False
+
+        updated = copy.deepcopy(settings)
+        updated["permissions"]["allow"].remove(tool_pattern)
+
+        # Clean up empty allow list
+        if not updated["permissions"]["allow"]:
+            del updated["permissions"]["allow"]
+
+        # Clean up empty permissions dict
+        if not updated["permissions"]:
+            del updated["permissions"]
+
+        self.save(updated)
+        return True
+
+    def list_permissions_matching(self, prefix: str) -> list[str]:
+        """Return entries from permissions.allow that start with prefix."""
+        settings = self.load()
+        return [
+            p for p in settings.get("permissions", {}).get("allow", [])
+            if p.startswith(prefix)
+        ]

{overcode-0.1.9 → overcode-0.2.0}/src/overcode/cli.py

@@ -56,6 +56,14 @@ skills_app = typer.Typer(
 )
 app.add_typer(skills_app, name="skills")
 
+# Perms subcommand group
+perms_app = typer.Typer(
+    name="perms",
+    help="Manage Claude Code tool permissions for overcode commands.",
+    no_args_is_help=True,
+)
+app.add_typer(perms_app, name="perms")
+
 # Budget subcommand group (#244)
 budget_app = typer.Typer(
     name="budget",
@@ -1265,6 +1273,148 @@ def skills_status():
                 rprint(f"  {name:<20} [yellow]modified[/yellow]")
 
 
+# =============================================================================
+# Perms Commands
+# =============================================================================
+
+OVERCODE_SAFE_PERMS = [
+    "Bash(overcode report *)",
+    "Bash(overcode show *)",
+    "Bash(overcode list *)",
+    "Bash(overcode follow *)",
+    "Bash(overcode kill *)",
+    "Bash(overcode budget *)",
+]
+
+OVERCODE_PUNCHY_PERMS = [
+    "Bash(overcode launch *)",
+    "Bash(overcode send *)",
+    "Bash(overcode instruct *)",
+]
+
+
+@perms_app.command("install")
+def perms_install(
+    project: Annotated[
+        bool,
+        typer.Option("--project", "-p", help="Install to project-level .claude/settings.json instead of user-level"),
+    ] = False,
+    all_perms: Annotated[
+        bool,
+        typer.Option("--all", help="Include punchy permissions (launch, send, instruct)"),
+    ] = False,
+):
+    """Install overcode tool permissions into Claude Code settings.
+
+    By default installs safe (read-only) permissions. Use --all to also
+    include punchy permissions that can spawn or control agents.
+
+    Safe: report, show, list, follow, kill, budget
+    Punchy (--all): launch, send, instruct
+    """
+    from .claude_config import ClaudeConfigEditor
+
+    if project:
+        editor = ClaudeConfigEditor.project_level()
+        level = "project"
+    else:
+        editor = ClaudeConfigEditor.user_level()
+        level = "user"
+
+    try:
+        editor.load()
+    except ValueError as e:
+        rprint(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    perms = OVERCODE_SAFE_PERMS + (OVERCODE_PUNCHY_PERMS if all_perms else [])
+
+    installed = 0
+    already = 0
+    for perm in perms:
+        if editor.add_permission(perm):
+            installed += 1
+        else:
+            already += 1
+
+    if installed > 0:
+        tier = "safe + punchy" if all_perms else "safe"
+        rprint(f"[green]\u2713[/green] Installed {installed} permission(s) in {level} settings ({tier})")
+        rprint(f"  [dim]{editor.path}[/dim]")
+        for perm in perms:
+            rprint(f"  {perm}")
+    elif already == len(perms):
+        rprint(f"[green]\u2713[/green] All {already} permissions already installed in {level} settings")
+
+
+@perms_app.command("uninstall")
+def perms_uninstall(
+    project: Annotated[
+        bool,
+        typer.Option("--project", "-p", help="Uninstall from project-level .claude/settings.json instead of user-level"),
+    ] = False,
+):
+    """Remove all overcode permissions from Claude Code settings."""
+    from .claude_config import ClaudeConfigEditor
+
+    if project:
+        editor = ClaudeConfigEditor.project_level()
+        level = "project"
+    else:
+        editor = ClaudeConfigEditor.user_level()
+        level = "user"
+
+    try:
+        editor.load()
+    except ValueError as e:
+        rprint(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    all_perms = OVERCODE_SAFE_PERMS + OVERCODE_PUNCHY_PERMS
+    removed = 0
+    for perm in all_perms:
+        if editor.remove_permission(perm):
+            removed += 1
+
+    if removed > 0:
+        rprint(f"[green]\u2713[/green] Removed {removed} permission(s) from {level} settings")
+    else:
+        rprint(f"[dim]No overcode permissions found in {level} settings[/dim]")
+
+
+@perms_app.command("status")
+def perms_status():
+    """Show which overcode permissions are installed."""
+    from .claude_config import ClaudeConfigEditor
+
+    all_perms = OVERCODE_SAFE_PERMS + OVERCODE_PUNCHY_PERMS
+
+    for level_name, editor in [
+        ("User-level", ClaudeConfigEditor.user_level()),
+        ("Project-level", ClaudeConfigEditor.project_level()),
+    ]:
+        try:
+            editor.load()
+        except ValueError:
+            rprint(f"\n{level_name} ({editor.path}):")
+            rprint(f"  [red](invalid JSON)[/red]")
+            continue
+
+        if not editor.path.exists():
+            rprint(f"\n{level_name} ({editor.path}):")
+            rprint(f"  [dim](no settings file)[/dim]")
+            continue
+
+        rprint(f"\n{level_name} ({editor.path}):")
+
+        installed = editor.list_permissions_matching("Bash(overcode ")
+        for perm in all_perms:
+            if perm in installed:
+                rprint(f"  {perm}  [green]\u2713[/green]")
+            else:
+                rprint(f"  {perm:<30} [dim]not installed[/dim]")
+
+
 @app.command("hook-handler", hidden=True)
 def hook_handler_cmd():
     """Handle Claude Code hook events (internal).

{overcode-0.1.9 → overcode-0.2.0}/src/overcode/history_reader.py

@@ -32,6 +32,30 @@ if TYPE_CHECKING:
 CLAUDE_HISTORY_PATH = Path.home() / ".claude" / "history.jsonl"
 CLAUDE_PROJECTS_PATH = Path.home() / ".claude" / "projects"
 
+# Model name → context window size in tokens.
+# Default 200K for unknown models.  Update as new models ship.
+MODEL_CONTEXT_WINDOWS: Dict[str, int] = {
+    "claude-opus-4-6": 200_000,
+    "claude-sonnet-4-5-20250929": 200_000,
+    "claude-haiku-4-5-20251001": 200_000,
+    "claude-3-5-sonnet-20241022": 200_000,
+    "claude-3-5-haiku-20241022": 200_000,
+    "claude-3-opus-20240229": 200_000,
+    "claude-3-sonnet-20240229": 200_000,
+    "claude-3-haiku-20240307": 200_000,
+}
+DEFAULT_CONTEXT_WINDOW = 200_000
+
+
+def model_context_window(model: Optional[str]) -> int:
+    """Return the context window size for a given model name.
+
+    Falls back to DEFAULT_CONTEXT_WINDOW for unknown/None models.
+    """
+    if not model:
+        return DEFAULT_CONTEXT_WINDOW
+    return MODEL_CONTEXT_WINDOWS.get(model, DEFAULT_CONTEXT_WINDOW)
+
 
 @dataclass
 class ClaudeSessionStats:
@@ -46,6 +70,12 @@ class ClaudeSessionStats:
     subagent_count: int = 0  # Number of subagent files (#176)
     live_subagent_count: int = 0  # Subagents with recently-modified files (#256)
     background_task_count: int = 0  # Number of background/farm tasks (#177)
+    model: Optional[str] = None  # Most recently seen model name (#272)
+
+    @property
+    def max_context_tokens(self) -> int:
+        """Context window size for the detected model."""
+        return model_context_window(self.model)
 
     @property
     def total_tokens(self) -> int:
@@ -151,7 +181,13 @@ class HistoryFile:
     def get_interactions_for_session(
         self, session: "Session"
     ) -> List[HistoryEntry]:
-        """Get history entries matching a session's directory and time window."""
+        """Get history entries matching a session's directory and time window.
+
+        When the session has known claude_session_ids, filters by sessionId
+        to avoid cross-contamination between agents sharing a directory (#264).
+        Falls back to directory+timestamp matching for older sessions without
+        tracked sessionIds.
+        """
         if not session.start_directory:
             return []
 
@@ -161,13 +197,21 @@ class HistoryFile:
         except (ValueError, TypeError):
             return []
 
+        # Use owned sessionIds when available for precise matching (#264)
+        owned_ids = set(getattr(session, 'claude_session_ids', None) or [])
+
         session_dir = str(Path(session.start_directory).resolve())
         matching = []
 
         for entry in self._entries():
             if entry.timestamp_ms < session_start_ms:
                 continue
-            if entry.project:
+            if owned_ids:
+                # Precise: only count interactions from this session's own Claude sessions
+                if entry.session_id in owned_ids:
+                    matching.append(entry)
+            elif entry.project:
+                # Fallback: directory matching for sessions without tracked IDs
                 entry_dir = str(Path(entry.project).resolve())
                 if entry_dir == session_dir:
                     matching.append(entry)
@@ -381,6 +425,7 @@ def read_token_usage_from_session_file(
         "cache_creation_tokens": 0,
         "cache_read_tokens": 0,
         "current_context_tokens": 0,  # Most recent input_tokens
+        "model": None,  # Most recently seen model name (#272)
     }
 
     if not session_file.exists():
@@ -411,6 +456,9 @@ def read_token_usage_from_session_file(
                                     pass
 
                         message = data.get("message", {})
+                        model = message.get("model")
+                        if model:
+                            totals["model"] = model
                         usage = message.get("usage", {})
                         if usage:
                             input_tokens = usage.get("input_tokens", 0)
@@ -520,9 +568,13 @@ def get_session_stats(
 
     Combines interaction counting with token usage from session files.
 
-    For context window calculation, only owned sessionIds are used to avoid
-    cross-contamination when multiple agents run in the same directory (#119).
-    Total token counting still uses all matched sessionIds.
+    Session scoping: get_interactions_for_session() is the single source of
+    truth for which Claude Code sessions belong to this overcode session.
+    When claude_session_ids are tracked, it filters precisely by sessionId;
+    otherwise falls back to directory+timestamp matching (#119, #264).
+
+    Context window uses active_claude_session_id after /clear (#116),
+    falling back to MAX across all matched sessions.
 
     Args:
         session: The overcode Session
@@ -542,7 +594,8 @@ def get_session_stats(
     except (ValueError, TypeError):
         return None
 
-    # Get interaction count and session IDs — use shared HistoryFile if provided
+    # get_interactions_for_session is the single gate for session scoping:
+    # uses claude_session_ids when available, else directory+timestamp fallback
     hf = history_file or (
         _default_history if history_path == CLAUDE_HISTORY_PATH
         else HistoryFile(history_path)
@@ -550,32 +603,26 @@ def get_session_stats(
     interactions = hf.get_interactions_for_session(session)
     interaction_count = len(interactions)
 
-    # Get unique session IDs from interactions (for total token counting)
-    all_session_ids = set()
-    for entry in interactions:
-        if entry.session_id:
-            all_session_ids.add(entry.session_id)
-
-    # Get owned sessionIds for token counting (#119)
-    owned_session_ids = getattr(session, 'claude_session_ids', None) or []
+    # Derive Claude sessionIds from the already-scoped interactions
+    session_ids = {e.session_id for e in interactions if e.session_id}
 
-    # Get active session ID for context calculation (#116)
-    # After /clear, only the active session's context is relevant
+    # Active session ID for context window after /clear (#116)
     active_session_id = getattr(session, 'active_claude_session_id', None)
 
-    # Sum token usage and work times across all session files
+    # Sum token usage and work times across session files
     total_input = 0
     total_output = 0
     total_cache_creation = 0
     total_cache_read = 0
-    current_context = 0  # Track context size from active session only (#116)
+    current_context = 0
+    detected_model: Optional[str] = None
     all_work_times: List[float] = []
     subagent_count = 0  # Count subagent files (#176)
     live_subagent_count = 0  # Subagents with recently-modified files (#256)
     background_task_count = 0  # Count background task files (#177)
     now = time.time()
 
-    for sid in all_session_ids:
+    for sid in session_ids:
         session_file = get_session_file_path(
             session.start_directory, sid, projects_path
         )
@@ -585,13 +632,17 @@ def get_session_stats(
         total_cache_creation += usage["cache_creation_tokens"]
         total_cache_read += usage["cache_read_tokens"]
 
-        # Context: use only the active session (#116), fall back to MAX of owned (#119)
+        # Context & model: prefer active session (#116), fall back to MAX across all
         if active_session_id:
             if sid == active_session_id:
                 current_context = usage["current_context_tokens"]
-        elif sid in owned_session_ids:
+                if usage["model"]:
+                    detected_model = usage["model"]
+        else:
             if usage["current_context_tokens"] > current_context:
                 current_context = usage["current_context_tokens"]
+            if usage["model"]:
+                detected_model = usage["model"]
 
         # Collect work times from this session file
         work_times = read_work_times_from_session_file(session_file, since=session_start)
@@ -630,4 +681,5 @@ def get_session_stats(
         subagent_count=subagent_count,
         live_subagent_count=live_subagent_count,
         background_task_count=background_task_count,
+        model=detected_model,
     )

{overcode-0.1.9 → overcode-0.2.0}/src/overcode/launcher.py

@@ -16,7 +16,7 @@ from pathlib import Path
 import re
 
 from .tmux_manager import TmuxManager
-from .tmux_utils import send_text_to_tmux_window
+from .tmux_utils import send_text_to_tmux_window, get_tmux_pane_content
 from .session_manager import SessionManager, Session
 from .config import get_default_standing_instructions
 from .dependency_check import require_tmux, require_claude
@@ -210,13 +210,55 @@ class ClaudeLauncher:
 
         return session
 
+    # Characters that indicate Claude's input prompt is ready
+    PROMPT_READY_CHARS = {">", "›", "❯"}
+
+    def _wait_for_prompt(
+        self,
+        window_index: int,
+        timeout: float = 30.0,
+        poll_interval: float = 0.5,
+    ) -> bool:
+        """Poll pane content until Claude's input prompt appears.
+
+        Returns True if prompt detected, False on timeout.
+        """
+        from .status_patterns import strip_ansi
+
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            content = get_tmux_pane_content(
+                self.tmux.session_name, window_index, lines=5
+            )
+            if content:
+                for line in content.split('\n'):
+                    cleaned = strip_ansi(line).strip()
+                    if cleaned in self.PROMPT_READY_CHARS:
+                        return True
+            time.sleep(poll_interval)
+        return False
+
     def _send_prompt_to_window(
         self,
         window_index: int,
         prompt: str,
         startup_delay: float = 3.0,
     ) -> bool:
-        """Send a prompt to a Claude session via tmux load-buffer/paste-buffer."""
+        """Send a prompt to a Claude session via tmux load-buffer/paste-buffer.
+
+        Polls for Claude's input prompt before sending. Falls back to
+        startup_delay if the prompt is not detected within 30 seconds.
+        """
+        if self._wait_for_prompt(window_index):
+            # Prompt detected — send immediately, no delay needed
+            return send_text_to_tmux_window(
+                self.tmux.session_name,
+                window_index,
+                prompt,
+                send_enter=True,
+                startup_delay=0,
+            )
+        # Fallback: prompt not detected, use original delay
         return send_text_to_tmux_window(
             self.tmux.session_name,
             window_index,

overcode-0.2.0/src/overcode/notifier.py

@@ -0,0 +1,145 @@
+"""
+macOS notification integration for agent bells (#235).
+
+Sends native notifications when agents transition to waiting_user state,
+so users working in other apps can hear/see when agents need attention.
+"""
+
+import shutil
+import subprocess
+import sys
+import time
+
+
+class MacNotifier:
+    """Coalescing macOS notifier for agent attention bells.
+
+    Queues agent names during a status update cycle, then flushes a single
+    coalesced notification at the end.  Uses terminal-notifier when available
+    (supports grouping/replacement), falling back to osascript.
+    """
+
+    MODES = ("off", "sound", "banner", "both")
+
+    def __init__(self, mode: str = "off", coalesce_seconds: float = 2.0):
+        self.mode = mode if mode in self.MODES else "off"
+        self.coalesce_seconds = coalesce_seconds
+        self._pending: list[tuple[str, str | None]] = []  # (name, task)
+        self._last_send: float = 0.0
+        self._has_terminal_notifier: bool | None = None  # lazy-detected
+
+    def queue(self, agent_name: str, task: str | None = None) -> None:
+        """Queue an agent bell for the current cycle.  No-ops when off or non-darwin."""
+        if self.mode == "off" or sys.platform != "darwin":
+            return
+        self._pending.append((agent_name, task))
+
+    def flush(self) -> None:
+        """Send a coalesced notification for all queued bells, then clear."""
+        if not self._pending or self.mode == "off" or sys.platform != "darwin":
+            self._pending.clear()
+            return
+
+        now = time.monotonic()
+        if now - self._last_send < self.coalesce_seconds:
+            # Too soon — hold until next cycle
+            return
+
+        names = [name for name, _ in self._pending]
+        task = self._pending[0][1] if len(self._pending) == 1 else None
+
+        subtitle, message = self._format(names, task)
+        self._send(message, subtitle)
+
+        self._last_send = now
+        self._pending.clear()
+
+    # ------------------------------------------------------------------
+    # Formatting
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _format(names: list[str], task: str | None) -> tuple[str | None, str]:
+        """Return (subtitle, message) for the notification.
+
+        subtitle is only set for single-agent + task (used by terminal-notifier).
+        """
+        if len(names) == 1:
+            msg = f"{names[0]} needs attention"
+            if task:
+                return msg, task
+            return None, msg
+        elif len(names) == 2:
+            return None, f"{names[0]} and {names[1]} need attention"
+        elif len(names) == 3:
+            return None, f"{names[0]}, {names[1]}, and {names[2]} need attention"
+        else:
+            others = len(names) - 2
+            return None, f"{names[0]}, {names[1]}, and {others} others need attention"
+
+    # ------------------------------------------------------------------
+    # Dispatch
+    # ------------------------------------------------------------------
+
+    def _send(self, message: str, subtitle: str | None = None) -> None:
+        """Fire-and-forget a macOS notification via best available backend."""
+        want_sound = self.mode in ("sound", "both")
+        want_banner = self.mode in ("banner", "both")
+
+        if self._use_terminal_notifier():
+            self._send_terminal_notifier(message, subtitle, want_sound, want_banner)
+        else:
+            self._send_osascript(message, subtitle, want_sound, want_banner)
+
+    def _use_terminal_notifier(self) -> bool:
+        if self._has_terminal_notifier is None:
+            self._has_terminal_notifier = shutil.which("terminal-notifier") is not None
+        return self._has_terminal_notifier
+
+    def _send_terminal_notifier(
+        self, message: str, subtitle: str | None,
+        want_sound: bool, want_banner: bool,
+    ) -> None:
+        cmd = ["terminal-notifier", "-title", "Overcode", "-group", "overcode-bell"]
+        if subtitle:
+            cmd += ["-subtitle", subtitle]
+        cmd += ["-message", message]
+        if want_sound:
+            cmd += ["-sound", "Hero"]
+        if not want_banner:
+            # terminal-notifier doesn't have a silent-banner flag;
+            # skip entirely if only sound is wanted
+            if not want_sound:
+                return
+            # sound-only: we still call terminal-notifier for the sound,
+            # but use a minimal notification that auto-dismisses
+        try:
+            subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        except OSError:
+            pass
+
+    def _send_osascript(
+        self, message: str, subtitle: str | None,
+        want_sound: bool, want_banner: bool,
+    ) -> None:
+        if want_banner:
+            display_text = f"{subtitle}\\n{message}" if subtitle else message
+            script = f'display notification "{display_text}" with title "Overcode"'
+            if want_sound:
+                script += ' sound name "Hero"'
+            try:
+                subprocess.Popen(
+                    ["osascript", "-e", script],
+                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                )
+            except OSError:
+                pass
+        elif want_sound:
+            # Sound-only via afplay (no banner)
+            try:
+                subprocess.Popen(
+                    ["afplay", "/System/Library/Sounds/Hero.aiff"],
+                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                )
+            except OSError:
+                pass

{overcode-0.1.9 → overcode-0.2.0}/src/overcode/settings.py

@@ -407,6 +407,7 @@ class TUIPreferences:
     monochrome: bool = False  # B&W mode for terminals with ANSI issues (#138)
     show_cost: bool = False  # Show $ cost instead of token counts
     timeline_hours: float = 3.0  # 1, 3, 6, 12, 24 — timeline scope (#191)
+    notifications: str = "off"  # "off", "sound", "banner", "both" — macOS notifications (#235)
     # Session IDs of stalled agents that have been visited by the user
     visited_stalled_agents: Set[str] = field(default_factory=set)
     # Column group visibility (group_id -> enabled) for summary line (#178)
@@ -455,6 +456,7 @@ class TUIPreferences:
                     visited_stalled_agents=set(data.get("visited_stalled_agents", [])),
                     summary_groups=data.get("summary_groups", default_summary_groups),
                     timeline_hours=data.get("timeline_hours", 3.0),
+                    notifications=data.get("notifications", "off"),
                 )
         except (json.JSONDecodeError, IOError):
             return cls()
@@ -485,6 +487,7 @@ class TUIPreferences:
                     "visited_stalled_agents": list(self.visited_stalled_agents),
                     "summary_groups": self.summary_groups,
                     "timeline_hours": self.timeline_hours,
+                    "notifications": self.notifications,
                 }, f, indent=2)
         except (IOError, OSError):
             pass  # Best effort