overcode 0.2.1__tar.gz → 0.2.2__tar.gz

{overcode-0.2.1/src/overcode.egg-info → overcode-0.2.2}/PKG-INFO

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

{overcode-0.2.1 → overcode-0.2.2}/pyproject.toml

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

{overcode-0.2.1 → overcode-0.2.2}/src/overcode/cli/agent.py

@@ -59,11 +59,65 @@ def launch(
         Optional[List[str]],
         typer.Option("--claude-arg", help="Extra Claude CLI flag (repeatable, e.g. '--model haiku')"),
     ] = None,
+    teams: Annotated[
+        bool,
+        typer.Option("--teams", help="Enable Claude Code agent teams (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS)"),
+    ] = False,
+    sister: Annotated[
+        Optional[str],
+        typer.Option("--sister", "-S", help="Launch on a remote sister machine (by name from config)"),
+    ] = None,
     session: SessionOption = "agents",
 ):
     """Launch a new Claude agent."""
     import os
 
+    # Remote launch via sister
+    if sister:
+        from ..config import get_sister_by_name
+        from ..sister_controller import SisterController
+
+        sister_config = get_sister_by_name(sister)
+        if not sister_config:
+            from ..config import get_sisters_config
+            available = [s["name"] for s in get_sisters_config()]
+            if available:
+                rprint(f"[red]Error: Sister '{sister}' not found. Available: {', '.join(available)}[/red]")
+            else:
+                rprint(f"[red]Error: No sisters configured. Add sisters to ~/.overcode/config.yaml[/red]")
+            raise typer.Exit(code=1)
+
+        remote_dir = directory if directory else "."
+        if not directory:
+            rprint("[yellow]Warning:[/yellow] No --directory given; remote agent will use '.'")
+
+        # Map permission flags to permissions string
+        if bypass_permissions:
+            permissions = "bypass"
+        elif skip_permissions:
+            permissions = "skip"
+        else:
+            permissions = "normal"
+
+        controller = SisterController()
+        result = controller.launch_agent(
+            sister_url=sister_config["url"],
+            api_key=sister_config.get("api_key", ""),
+            directory=remote_dir,
+            name=name,
+            prompt=prompt,
+            permissions=permissions,
+        )
+
+        if result.ok:
+            rprint(f"\n[green]✓[/green] Remote agent '[bold]{name}[/bold]' launched on [bold]{sister}[/bold]")
+            if prompt:
+                rprint("  Initial prompt sent")
+        else:
+            rprint(f"[red]Error: Remote launch failed: {result.error}[/red]")
+            raise typer.Exit(code=1)
+        return
+
     # Parse oversight policy
     oversight_policy = "wait"
     oversight_timeout_seconds = 0.0
@@ -104,6 +158,7 @@ def launch(
         parent_name=parent,
         allowed_tools=allowed_tools,
         extra_claude_args=claude_args,
+        agent_teams=teams,
     )
 
     if result:
@@ -116,6 +171,8 @@ def launch(
             rprint(f"  Allowed tools: {allowed_tools}")
         if claude_args:
             rprint(f"  Extra Claude args: {' '.join(claude_args)}")
+        if teams:
+            rprint("  Agent teams: enabled")
 
         # Store oversight policy on session
         if oversight_policy != "wait" or oversight_timeout_seconds > 0:
@@ -155,6 +212,15 @@ def list_agents(
     sisters: Annotated[
         bool, typer.Option("--sisters", help="Include sister (remote) agents")
     ] = False,
+    low: Annotated[
+        bool, typer.Option("--low", help="Low detail (identity only)")
+    ] = False,
+    med: Annotated[
+        bool, typer.Option("--med", help="Medium detail")
+    ] = False,
+    full: Annotated[
+        bool, typer.Option("--full", help="Full detail (default)")
+    ] = False,
     session: SessionOption = "agents",
 ):
     """List running agents with status.
@@ -170,19 +236,30 @@ def list_agents(
         get_status_symbol, get_git_diff_stats,
     )
     from ..monitor_daemon_state import get_monitor_daemon_state
-    from ..summary_columns import build_cli_context, SUMMARY_COLUMNS
+    from ..summary_columns import build_cli_context, render_summary_cells, align_summary_rows
     from ..tui_logic import compute_tree_metadata, sort_sessions_by_tree
-    from rich.text import Text
     from rich.console import Console
 
+    # Resolve detail level (mutually exclusive flags, default full)
+    if low:
+        detail = "low"
+    elif med:
+        detail = "med"
+    else:
+        detail = "full"
+
     launcher = ClaudeLauncher(session)
     sessions = launcher.list_sessions()
 
     # Merge sister sessions if --sisters flag
+    has_sisters = False
+    local_hostname = ""
     if sisters:
         from ..sister_poller import SisterPoller
         poller = SisterPoller()
-        if poller.has_sisters:
+        has_sisters = poller.has_sisters
+        local_hostname = poller.local_hostname
+        if has_sisters:
             remote_sessions = poller.poll_all()
             sessions = sessions + remote_sessions
 
@@ -212,23 +289,38 @@ def list_agents(
     sessions = sort_sessions_by_tree(sessions)
     tree_meta = compute_tree_metadata(sessions)
 
-    # Columns to render in list mode (subset of TUI columns)
-    list_columns = {
-        "status_symbol", "time_in_state", "sleep_countdown", "agent_name",
-        "git_diff",
-        "uptime", "running_time", "stalled_time", "sleep_time",
-        "token_count", "cost", "budget", "context_usage",
-    }
-
-    # Pre-compute: any agent with budget, max name width
+    # Pre-compute: any agent with budget, column alignment widths
     any_has_budget = any(s.cost_budget_usd > 0 for s in sessions)
     max_name_len = max(len(s.name) for s in sessions)
     name_width = min(max(max_name_len, 10), 20)
+    max_repo_width = max((len(s.repo_name or "n/a") for s in sessions), default=5)
+    max_branch_width = max((len(s.branch or "n/a") for s in sessions), default=5)
+    all_names_match_repos = all(
+        s.name == s.repo_name for s in sessions if s.repo_name
+    )
 
     # Prefer daemon state for status/activity (single source of truth)
     daemon_state = get_monitor_daemon_state(session)
     use_daemon = daemon_state is not None and not daemon_state.is_stale()
 
+    # Compute cross-session flags from daemon state
+    any_has_oversight_timeout = False
+    any_has_pr = False
+    if use_daemon:
+        any_has_oversight_timeout = any(
+            ds.oversight_timeout_seconds > 0
+            for ds in daemon_state.sessions
+        )
+    else:
+        any_has_oversight_timeout = any(
+            getattr(s, 'oversight_timeout_seconds', 0) > 0
+            for s in sessions
+        )
+    any_has_pr = any(
+        getattr(s, 'pr_number', None) is not None
+        for s in sessions
+    )
+
     # Only create detector as fallback when daemon isn't running
     detector = None
     if not use_daemon:
@@ -288,24 +380,43 @@ def list_agents(
     # Compute cross-session flags
     any_is_sleeping = any(st == "busy_sleeping" for _, st, _, _, _ in session_data)
 
-    # Second pass: render
+    # Second pass: build contexts and collect cells for auto-alignment
+    all_cells = []
+    activities = []
     for sess, status, activity, claude_stats, git_diff in session_data:
         meta = tree_meta.get(sess.id)
         child_count = meta.child_count if meta else 0
+
+        # Get per-session daemon fields
+        oversight_deadline = None
+        if use_daemon:
+            ds = daemon_state.get_session_by_name(sess.name)
+            if ds:
+                oversight_deadline = ds.oversight_deadline
+
+        _, status_color = get_status_symbol(status)
         ctx = build_cli_context(
             session=sess, stats=sess.stats,
             claude_stats=claude_stats, git_diff_stats=git_diff,
             status=status, bg_bash_count=0, live_sub_count=0,
             any_has_budget=any_has_budget, child_count=child_count,
             any_is_sleeping=any_is_sleeping,
+            any_has_oversight_timeout=any_has_oversight_timeout,
+            oversight_deadline=oversight_deadline,
+            pr_number=getattr(sess, 'pr_number', None),
+            any_has_pr=any_has_pr,
+            monochrome=False,
+            summary_detail=detail,
+            has_sisters=has_sisters,
+            local_hostname=local_hostname,
+            max_name_width=name_width,
+            max_repo_width=max_repo_width,
+            max_branch_width=max_branch_width,
+            all_names_match_repos=all_names_match_repos,
         )
-
-        # Enable colors and set detail level for list view
-        ctx.monochrome = False
-        _, status_color = get_status_symbol(status)
         ctx.status_color = f"bold {status_color}"
-        ctx.summary_detail = "med"
         ctx.show_cost = cost
+        ctx.is_list_mode = True
 
         # Handle tree indentation (#244) using compute_tree_metadata
         depth = meta.depth if meta else 0
@@ -313,23 +424,15 @@ def list_agents(
         available = name_width - len(indent)
         ctx.display_name = (indent + sess.name[:available]).ljust(name_width)
 
-        # Render line using column system
-        line = Text()
-        for col in SUMMARY_COLUMNS:
-            if col.id not in list_columns:
-                continue
-            if ctx.summary_detail not in col.detail_levels:
-                continue
-            segments = col.render(ctx)
-            if segments:
-                for text, style in segments:
-                    line.append(text, style=style)
-
-        # Append activity (truncate to fit terminal width)
+        all_cells.append(render_summary_cells(ctx))
+        activities.append(activity)
+
+    # Auto-align columns across all rows, then append activity
+    aligned_lines = align_summary_rows(all_cells)
+    for line, activity in zip(aligned_lines, activities):
         line.append(" │ ", style="dim")
         line.append(activity)
         line.truncate(console.width, pad=False)
-
         console.print(line, no_wrap=True)
 
     if terminated_count > 0:
@@ -756,6 +859,8 @@ def show(
             print(f"{'Tools:':<{label_width + 1}} {sess.allowed_tools}")
         if sess.extra_claude_args:
             print(f"{'Claude args:':<{label_width + 1}} {' '.join(sess.extra_claude_args)}")
+        if sess.agent_teams:
+            print(f"{'Teams:':<{label_width + 1}} enabled")
 
         print()
 

{overcode-0.2.1 → overcode-0.2.2}/src/overcode/config.py

@@ -264,6 +264,36 @@ def get_web_allow_control() -> bool:
     return bool(web.get("allow_control", False))
 
 
+def get_new_agent_defaults() -> dict:
+    """Get new-agent default settings from config.
+
+    Config format in ~/.overcode/config.yaml:
+        new_agent_defaults:
+          bypass_permissions: false
+          agent_teams: false
+
+    Returns:
+        Dict with bypass_permissions (bool) and agent_teams (bool).
+    """
+    config = load_config()
+    defaults = config.get("new_agent_defaults", {})
+    return {
+        "bypass_permissions": bool(defaults.get("bypass_permissions", False)),
+        "agent_teams": bool(defaults.get("agent_teams", False)),
+    }
+
+
+def save_new_agent_defaults(defaults: dict) -> None:
+    """Save new-agent default settings to config.
+
+    Args:
+        defaults: Dict with bypass_permissions and agent_teams booleans.
+    """
+    config = load_config()
+    config["new_agent_defaults"] = defaults
+    save_config(config)
+
+
 def get_sisters_config() -> List[dict]:
     """Get sister instance configuration for cross-machine monitoring.
 
@@ -298,3 +328,15 @@ def get_sisters_config() -> List[dict]:
         result.append(entry)
 
     return result
+
+
+def get_sister_by_name(name: str) -> Optional[dict]:
+    """Look up a sister config by name.
+
+    Returns:
+        Sister config dict (name, url, optional api_key) or None if not found.
+    """
+    for sister in get_sisters_config():
+        if sister["name"] == name:
+            return sister
+    return None

{overcode-0.2.1 → overcode-0.2.2}/src/overcode/history_reader.py

@@ -404,31 +404,35 @@ def get_session_file_path(
     return projects_path / encoded / f"{session_id}.jsonl"
 
 
-def read_token_usage_from_session_file(
+def read_session_file_stats(
     session_file: Path,
-    since: Optional[datetime] = None
-) -> dict:
-    """Read token usage from a Claude Code session JSONL file.
+    since: Optional[datetime] = None,
+) -> Tuple[dict, List[float]]:
+    """Read token usage and work times from a session file in a single pass.
+
+    Combines the work of read_token_usage_from_session_file and
+    read_work_times_from_session_file so the file is only read once.
 
     Args:
         session_file: Path to the session JSONL file
-        since: Only count tokens from messages after this time
+        since: Only count data from messages after this time
 
     Returns:
-        Dict with input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
-        and current_context_tokens (most recent input_tokens value)
+        (token_usage_dict, work_times_list)
     """
     totals = {
         "input_tokens": 0,
         "output_tokens": 0,
         "cache_creation_tokens": 0,
         "cache_read_tokens": 0,
-        "current_context_tokens": 0,  # Most recent input_tokens
-        "model": None,  # Most recently seen model name (#272)
+        "current_context_tokens": 0,
+        "model": None,
     }
 
     if not session_file.exists():
-        return totals
+        return totals, []
+
+    user_prompt_times: List[datetime] = []
 
     try:
         with open(session_file, 'r') as f:
@@ -438,14 +442,14 @@ def read_token_usage_from_session_file(
                     continue
                 try:
                     data = json.loads(line)
-                    # Only assistant messages have usage data
-                    if data.get("type") == "assistant":
+                    msg_type = data.get("type")
+
+                    if msg_type == "assistant":
                         # Check timestamp if filtering by time
                         if since:
                             ts_str = data.get("timestamp")
                             if ts_str:
                                 try:
-                                    # Parse ISO timestamp (e.g., "2026-01-02T06:56:01.975Z")
                                     msg_time = datetime.fromisoformat(
                                         ts_str.replace("Z", "+00:00")
                                     ).replace(tzinfo=None)
@@ -468,15 +472,62 @@ def read_token_usage_from_session_file(
                                 "cache_creation_input_tokens", 0
                             )
                             totals["cache_read_tokens"] += cache_read
-                            # Track most recent context size (input + cached context)
                             context_size = input_tokens + cache_read
                             if context_size > 0:
                                 totals["current_context_tokens"] = context_size
+
+                    elif msg_type == "user":
+                        # Check if this is an actual user prompt (not a tool result)
+                        message = data.get("message", {})
+                        content = message.get("content", "")
+                        if isinstance(content, list):
+                            if content and content[0].get("type") == "tool_result":
+                                continue
+
+                        ts_str = data.get("timestamp")
+                        if not ts_str:
+                            continue
+
+                        try:
+                            msg_time = datetime.fromisoformat(
+                                ts_str.replace("Z", "+00:00")
+                            ).replace(tzinfo=None)
+                            if since and msg_time < since:
+                                continue
+                            user_prompt_times.append(msg_time)
+                        except (ValueError, TypeError):
+                            continue
+
                 except (json.JSONDecodeError, KeyError, TypeError):
                     continue
     except IOError:
-        pass
+        return totals, []
+
+    # Calculate durations between consecutive prompts
+    work_times = []
+    for i in range(1, len(user_prompt_times)):
+        duration = (user_prompt_times[i] - user_prompt_times[i - 1]).total_seconds()
+        if duration > 0:
+            work_times.append(duration)
+
+    return totals, work_times
+
+
+def read_token_usage_from_session_file(
+    session_file: Path,
+    since: Optional[datetime] = None
+) -> dict:
+    """Read token usage from a Claude Code session JSONL file.
+
+    Args:
+        session_file: Path to the session JSONL file
+        since: Only count tokens from messages after this time
 
+    Returns:
+        Dict with input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+        and current_context_tokens (most recent input_tokens value)
+    """
+    totals, _ = read_session_file_stats(session_file, since)
     return totals
 
 
@@ -498,62 +549,7 @@ def read_work_times_from_session_file(
     Returns:
         List of work times in seconds
     """
-    if not session_file.exists():
-        return []
-
-    user_prompt_times: List[datetime] = []
-
-    try:
-        with open(session_file, 'r') as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    data = json.loads(line)
-                    if data.get("type") != "user":
-                        continue
-
-                    # Check if this is an actual user prompt (not a tool result)
-                    message = data.get("message", {})
-                    content = message.get("content", "")
-
-                    # Tool results have content as a list with tool_result type
-                    if isinstance(content, list):
-                        # Check if it's a tool result
-                        if content and content[0].get("type") == "tool_result":
-                            continue
-
-                    # Parse timestamp
-                    ts_str = data.get("timestamp")
-                    if not ts_str:
-                        continue
-
-                    try:
-                        msg_time = datetime.fromisoformat(
-                            ts_str.replace("Z", "+00:00")
-                        ).replace(tzinfo=None)
-
-                        # Filter by since time
-                        if since and msg_time < since:
-                            continue
-
-                        user_prompt_times.append(msg_time)
-                    except (ValueError, TypeError):
-                        continue
-
-                except (json.JSONDecodeError, KeyError, TypeError):
-                    continue
-    except IOError:
-        return []
-
-    # Calculate durations between consecutive prompts
-    work_times = []
-    for i in range(1, len(user_prompt_times)):
-        duration = (user_prompt_times[i] - user_prompt_times[i - 1]).total_seconds()
-        if duration > 0:
-            work_times.append(duration)
-
+    _, work_times = read_session_file_stats(session_file, since)
     return work_times
 
 
@@ -625,7 +621,7 @@ def get_session_stats(
         session_file = get_session_file_path(
             session.start_directory, sid, projects_path
         )
-        usage = read_token_usage_from_session_file(session_file, since=session_start)
+        usage, work_times = read_session_file_stats(session_file, since=session_start)
         total_input += usage["input_tokens"]
         total_output += usage["output_tokens"]
         total_cache_creation += usage["cache_creation_tokens"]
@@ -644,7 +640,6 @@ def get_session_stats(
                 detected_model = usage["model"]
 
         # Collect work times from this session file
-        work_times = read_work_times_from_session_file(session_file, since=session_start)
         all_work_times.extend(work_times)
 
         # Check for subagent files in {sessionId}/subagents/
@@ -655,7 +650,7 @@ def get_session_stats(
                 subagent_count += 1
                 if now - subagent_file.stat().st_mtime < 30:
                     live_subagent_count += 1
-                sub_usage = read_token_usage_from_session_file(
+                sub_usage, _ = read_session_file_stats(
                     subagent_file, since=session_start
                 )
                 total_input += sub_usage["input_tokens"]

{overcode-0.2.1 → overcode-0.2.2}/src/overcode/launcher.py

@@ -11,6 +11,7 @@ import time
 import subprocess
 import os
 import shlex
+from pathlib import Path
 from typing import List, Optional
 
 import re
@@ -77,6 +78,7 @@ class ClaudeLauncher:
         parent_name: Optional[str] = None,
         allowed_tools: Optional[str] = None,
         extra_claude_args: Optional[List[str]] = None,
+        agent_teams: bool = False,
     ) -> Optional[Session]:
         """
         Launch an interactive Claude Code session in a tmux window.
@@ -175,6 +177,10 @@ class ClaudeLauncher:
         if parent_session:
             env_prefix += f" OVERCODE_PARENT_SESSION_ID={parent_session.id} OVERCODE_PARENT_NAME={parent_session.name}"
 
+        # Enable Claude Code agent teams if requested
+        if agent_teams:
+            env_prefix += " CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1"
+
         # If MOCK_SCENARIO is set, prepend it to the command for testing
         mock_scenario = os.environ.get("MOCK_SCENARIO")
         if mock_scenario:
@@ -198,16 +204,19 @@ class ClaudeLauncher:
 
         # Register session with default standing instructions from config
         default_instructions = get_default_standing_instructions()
+        # Resolve to absolute path so daemon/CLI don't disagree on CWD (#312)
+        resolved_directory = str(Path(start_directory).resolve()) if start_directory else None
         session = self.sessions.create_session(
             name=name,
             tmux_session=self.tmux.session_name,
             tmux_window=window_index,
             command=claude_cmd,
-            start_directory=start_directory,
+            start_directory=resolved_directory,
             standing_instructions=default_instructions,
             permissiveness_mode=perm_mode,
             allowed_tools=allowed_tools,
             extra_claude_args=extra_claude_args,
+            agent_teams=agent_teams,
         )
 
         # Set parent if launching as child agent (#244)
@@ -467,6 +476,33 @@ class ClaudeLauncher:
             print(f"Session '{name}' not found")
             return False
 
+        return self._send_to_resolved_session(session, text, enter)
+
+    def send_to_session_by_id(self, session_id: str, text: str, enter: bool = True) -> bool:
+        """Send text/keys to a session by ID.
+
+        Preferred over send_to_session() when the session ID is known,
+        since IDs are unique even when local and remote agents share a name.
+
+        Args:
+            session_id: Unique session ID
+            text: Text to send (or special key like "Enter", "Escape")
+            enter: Whether to press Enter after the text (default: True)
+
+        Returns:
+            True if successful, False otherwise
+        """
+        session = self.sessions.get_session(session_id)
+        if session is None:
+            return False
+
+        return self._send_to_resolved_session(session, text, enter)
+
+    def _send_to_resolved_session(self, session: Session, text: str, enter: bool = True) -> bool:
+        """Send text/keys to an already-resolved session.
+
+        Internal helper shared by send_to_session() and send_to_session_by_id().
+        """
         # Handle special keys
         special_keys = {
             "enter": "",  # Empty string + Enter = just press Enter

{overcode-0.2.1 → overcode-0.2.2}/src/overcode/monitor_daemon.py

@@ -63,6 +63,7 @@ from .status_constants import (
     is_green_status,
 )
 from .status_detector import StatusDetector
+from .status_patterns import extract_pr_number
 from .status_detector_factory import StatusDetectorDispatcher
 from .status_history import log_agent_status
 from .monitor_daemon_core import (
@@ -191,7 +192,7 @@ class PresenceComponent:
             self._last_publish_time = now
             return False
         gap = (now - self._last_publish_time).total_seconds()
-        slept = gap > 2 * DAEMON.interval_fast
+        slept = gap > 20  # Machine sleep produces gaps of 30s+; absolute threshold avoids false positives
         self._last_publish_time = now
         return slept
 
@@ -637,7 +638,7 @@ class MonitorDaemon:
 
     def _interruptible_sleep(self, total_seconds: int) -> None:
         """Sleep with activity signal checking."""
-        chunk_size = 10
+        chunk_size = 1
         elapsed = 0
 
         while elapsed < total_seconds and not self._shutdown:
@@ -849,7 +850,13 @@ class MonitorDaemon:
                 status, activity = STATUS_DONE, "Completed"
             else:
                 # Detect status - dispatches per-session via dispatcher (#5)
-                status, activity, _ = self.detector.detect_status(session)
+                status, activity, pane_content = self.detector.detect_status(session)
+
+                # Extract PR number from pane content
+                if pane_content:
+                    pr = extract_pr_number(pane_content)
+                    if pr is not None and pr != session.pr_number:
+                        self.session_manager.update_session(session.id, pr_number=pr)
 
             # Clear heartbeat tracking when session stops running
             if status != STATUS_RUNNING and session.id in self._sessions_running_from_heartbeat: