overcode 0.2.1__tar.gz → 0.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overcode
-Version: 0.2.1
+Version: 0.2.3
 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.3}/pyproject.toml

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

overcode-0.2.3/src/overcode/agent_scanner.py

@@ -0,0 +1,38 @@
+"""
+Scan for Claude Code agent definitions (.md files in .claude/agents/).
+"""
+
+from pathlib import Path
+from typing import List
+
+
+def scan_agents(directory: str) -> List[str]:
+    """Scan for available Claude agent definitions.
+
+    Checks both project-level (.claude/agents/) and user-level (~/.claude/agents/)
+    directories for .md files. Returns deduplicated, sorted list of agent names
+    (filenames without .md extension).
+
+    Args:
+        directory: Project directory to scan for project-level agents.
+
+    Returns:
+        Sorted list of agent names. Empty list if none found.
+    """
+    names: set = set()
+
+    # Project-level agents
+    project_dir = Path(directory) / ".claude" / "agents"
+    if project_dir.is_dir():
+        for f in project_dir.iterdir():
+            if f.is_file() and f.suffix == ".md":
+                names.add(f.stem)
+
+    # User-level agents
+    user_dir = Path.home() / ".claude" / "agents"
+    if user_dir.is_dir():
+        for f in user_dir.iterdir():
+            if f.is_file() and f.suffix == ".md":
+                names.add(f.stem)
+
+    return sorted(names)

{overcode-0.2.1 → overcode-0.2.3}/src/overcode/bundled_skills.py

@@ -32,6 +32,7 @@ overcode launch -n <name> [-d <path>] [-p "<prompt>"] [--follow] [--bypass-permi
 overcode launch -n <name> --follow --oversight-timeout 5m -p "... When done: overcode report --status success"
 overcode launch -n <name> --allowed-tools "Read,Glob,Grep" --skip-permissions
 overcode launch -n <name> --claude-arg "--model haiku" --claude-arg "--effort low"
+overcode launch -n <name> --budget 2.00 -p "..."  # Set cost budget (auto-deducted from parent)
 
 # Monitor
 overcode list [name] [--show-done]
@@ -127,8 +128,8 @@ overcode launch --name fix-auth-bug -d ~/project --follow --bypass-permissions \
 ## Parallel (Non-Blocking)
 
 ```bash
-overcode launch -n refactor-api -d ~/project -p "Refactor REST API. When done: overcode report --status success" --bypass-permissions
-overcode launch -n write-tests -d ~/project -p "Write auth tests. When done: overcode report --status success" --bypass-permissions
+overcode launch -n refactor-api -d ~/project --budget 3.00 -p "Refactor REST API. When done: overcode report --status success" --bypass-permissions
+overcode launch -n write-tests -d ~/project --budget 2.00 -p "Write auth tests. When done: overcode report --status success" --bypass-permissions
 
 overcode list                       # Monitor progress
 overcode show refactor-api -n 100   # Read output
@@ -163,6 +164,10 @@ Children must call `overcode report --status success|failure [--reason "..."]` w
 ## Budget Control
 
 ```bash
+# Preferred: set budget at launch (auto-deducted from parent if parent has budget)
+overcode launch -n child-agent -d ~/project --bypass-permissions --budget 2.00 -p "..."
+
+# Manual budget management
 overcode budget transfer my-agent child-agent 2.00   # Transfer from your budget
 overcode budget set child-agent 3.00                  # Set directly
 ```

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

@@ -59,11 +59,73 @@ def launch(
         Optional[List[str]],
         typer.Option("--claude-arg", help="Extra Claude CLI flag (repeatable, e.g. '--model haiku')"),
     ] = None,
+    budget: Annotated[
+        Optional[float],
+        typer.Option("--budget", "-b", help="Cost budget in USD (deducted from parent if parent has budget)"),
+    ] = None,
+    agent: Annotated[
+        Optional[str],
+        typer.Option("--agent", "-a", help="Claude agent to run as (from .claude/agents/)"),
+    ] = 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 +166,9 @@ def launch(
         parent_name=parent,
         allowed_tools=allowed_tools,
         extra_claude_args=claude_args,
+        agent_teams=teams,
+        budget_usd=budget,
+        claude_agent=agent,
     )
 
     if result:
@@ -116,6 +181,12 @@ def launch(
             rprint(f"  Allowed tools: {allowed_tools}")
         if claude_args:
             rprint(f"  Extra Claude args: {' '.join(claude_args)}")
+        if agent:
+            rprint(f"  Agent: {agent}")
+        if teams:
+            rprint("  Agent teams: enabled")
+        if budget is not None and budget > 0:
+            rprint(f"  Budget: ${budget:.2f}")
 
         # Store oversight policy on session
         if oversight_policy != "wait" or oversight_timeout_seconds > 0:
@@ -155,6 +226,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 +250,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 +303,48 @@ 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
+    subtree_costs = {}
+    if use_daemon:
+        any_has_oversight_timeout = any(
+            ds.oversight_timeout_seconds > 0
+            for ds in daemon_state.sessions
+        )
+        for ds in daemon_state.sessions:
+            if ds.subtree_cost_usd > 0:
+                subtree_costs[ds.session_id] = ds.subtree_cost_usd
+    # Also extract from remote sessions via forwarded daemon_state
+    for s in sessions:
+        rds = getattr(s, 'remote_daemon_state', None)
+        if rds and rds.get('subtree_cost_usd', 0) > 0:
+            subtree_costs[s.id] = rds['subtree_cost_usd']
+    if not use_daemon:
+        any_has_oversight_timeout = any(
+            getattr(s, 'oversight_timeout_seconds', 0) > 0
+            for s in sessions
+        )
+    any_has_subtree_cost = bool(subtree_costs)
+    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 +404,45 @@ 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,
+            subtree_cost_usd=subtree_costs.get(sess.id, 0.0),
+            any_has_subtree_cost=any_has_subtree_cost,
         )
-
-        # 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 +450,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 +885,10 @@ 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.claude_agent:
+            print(f"{'Agent:':<{label_width + 1}} {sess.claude_agent}")
+        if sess.agent_teams:
+            print(f"{'Teams:':<{label_width + 1}} enabled")
 
         print()
 

{overcode-0.2.1 → overcode-0.2.3}/src/overcode/cli/daemon.py

@@ -35,7 +35,7 @@ def monitor_daemon_start(
     - Status detection (running, waiting, etc.)
     - Time accumulation (green_time, non_green_time)
     - Claude Code stats (tokens, interactions)
-    - User presence state (macOS only)
+    - User presence state
     """
     from ..monitor_daemon import MonitorDaemon, is_monitor_daemon_running, get_monitor_daemon_pid
 

{overcode-0.2.1 → overcode-0.2.3}/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.3}/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"]