overcode 0.3.4__tar.gz → 0.3.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overcode
-Version: 0.3.4
+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.4 → overcode-0.3.6}/pyproject.toml

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

{overcode-0.3.4 → overcode-0.3.6}/src/overcode/bundled_skills.py

@@ -94,8 +94,10 @@ overcode bash "make deploy-staging" --agent my-agent   # Link to an agent
 
 # Manage jobs
 overcode jobs list [--all]        # List running (or all) jobs
+overcode jobs tail <name>         # Stream output (works without TTY)
+overcode jobs tail <name> -n 50   # Last 50 lines and exit
 overcode jobs kill <name>         # Kill a running job
-overcode jobs attach <name>       # Attach to job's tmux window
+overcode jobs attach <name>       # Attach to job's tmux window (needs TTY)
 overcode jobs clear               # Remove completed/failed/killed jobs
 
 # TUI: press J to toggle jobs view, j/k to navigate, x to kill, c to clear
@@ -227,7 +229,8 @@ overcode bash "npm run build" --name frontend-build --agent my-agent
 
 # Check on it later
 overcode jobs list
-overcode jobs attach full-tests    # Attach to see live output
+overcode jobs tail full-tests      # Stream output (no TTY needed)
+overcode jobs tail full-tests -n 50  # Last 50 lines snapshot
 overcode jobs kill full-tests      # Kill if needed
 ```
 

{overcode-0.3.4 → overcode-0.3.6}/src/overcode/cli/agent.py

@@ -212,6 +212,10 @@ def launch(
         bool,
         typer.Option("--teams", help="Enable Claude Code agent teams (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS)"),
     ] = False,
+    provider: Annotated[
+        Optional[str],
+        typer.Option("--provider", "-P", help="API provider: 'web' (Claude.ai OAuth) or 'bedrock' (AWS Bedrock)"),
+    ] = None,
     sister: Annotated[
         Optional[str],
         typer.Option("--sister", "-S", help="Launch on a remote sister machine (by name from config)"),
@@ -270,6 +274,15 @@ def launch(
     # Parse oversight policy
     oversight_policy, oversight_timeout_seconds = _parse_oversight_policy(on_stuck, oversight_timeout)
 
+    # Resolve provider: CLI flag > config default > "web"
+    resolved_provider = provider
+    if resolved_provider is None:
+        from ..config import get_new_agent_defaults
+        resolved_provider = get_new_agent_defaults().get("provider", "web")
+    if resolved_provider not in ("web", "bedrock"):
+        rprint(f"[red]Error: Invalid provider '{resolved_provider}'. Use: web, bedrock[/red]")
+        raise typer.Exit(code=1)
+
     # Default to current directory if not specified
     working_dir = directory if directory else os.getcwd()
 
@@ -288,6 +301,7 @@ def launch(
         budget_usd=budget,
         claude_agent=agent,
         model=model,
+        provider=resolved_provider,
     )
 
     if result:
@@ -304,6 +318,8 @@ def launch(
             rprint(f"  Agent: {agent}")
         if teams:
             rprint("  Agent teams: enabled")
+        if resolved_provider != "web":
+            rprint(f"  Provider: {resolved_provider}")
         if budget is not None and budget > 0:
             rprint(f"  Budget: ${budget:.2f}")
 
@@ -479,6 +495,8 @@ def list_agents(
 
     # Pre-compute: any agent with budget, column alignment widths
     any_has_budget = any(s.cost_budget_usd > 0 for s in sessions)
+    any_has_provider = any(getattr(s, 'provider', 'web') not in ('web', None, '') for s in sessions)
+    any_has_model = any(getattr(s, 'model', None) for s in sessions)
     max_name_len = max((len(s.name) for s in sessions), default=10)
     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)
@@ -585,6 +603,8 @@ def list_agents(
             oversight_deadline=oversight_deadline,
             pr_number=getattr(sess, 'pr_number', None),
             any_has_pr=any_has_pr,
+            any_has_model=any_has_model,
+            any_has_provider=any_has_provider,
             monochrome=False,
             summary_detail=detail,
             has_sisters=has_sisters,
@@ -673,6 +693,59 @@ def kill(
     launcher.kill_session(name, cascade=not no_cascade)
 
 
+@app.command()
+def restart(
+    name: Annotated[str, typer.Argument(help="Name of agent to restart")],
+    session: SessionOption = "agents",
+):
+    """Restart a running agent with the same configuration.
+
+    Gracefully exits Claude (Ctrl-C + /exit), then relaunches with the
+    same permissions mode. Useful when MCP server configs change.
+    """
+    import os
+    import time
+    from ..session_manager import SessionManager
+    from ..tmux_manager import TmuxManager
+    from ..tmux_utils import tmux_window_target, _build_tmux_cmd
+
+    sm = SessionManager()
+    sess = sm.get_session_by_name(name)
+    if not sess:
+        rprint(f"[red]Error: Agent '{name}' not found[/red]")
+        raise typer.Exit(code=1)
+
+    tmux = TmuxManager(session)
+    if not tmux.window_exists(sess.tmux_window):
+        rprint(f"[red]Error: Tmux window for '{name}' no longer exists[/red]")
+        raise typer.Exit(code=1)
+
+    # Build the claude command based on permissiveness mode
+    claude_command = os.environ.get("CLAUDE_COMMAND", "claude")
+    cmd_parts = [claude_command]
+    if sess.permissiveness_mode == "bypass":
+        cmd_parts.append("--dangerously-skip-permissions")
+    elif sess.permissiveness_mode == "permissive":
+        cmd_parts.extend(["--permission-mode", "dontAsk"])
+    cmd_str = " ".join(cmd_parts)
+
+    # Gracefully exit Claude: Ctrl-C + /exit
+    rprint(f"[dim]Stopping '{name}'...[/dim]")
+    tmux.send_keys(sess.tmux_window, "C-c", enter=False)
+    time.sleep(0.5)
+    tmux.send_keys(sess.tmux_window, "/exit", enter=True)
+    time.sleep(3.0)
+
+    # Relaunch
+    if tmux.send_keys(sess.tmux_window, cmd_str, enter=True):
+        sm.update_stats(sess.id, current_task="Restarting...")
+        sm.update_session(sess.id, claude_session_ids=[])
+        rprint(f"[green]Restarted agent: {name}[/green]")
+    else:
+        rprint(f"[red]Failed to restart agent: {name}[/red]")
+        raise typer.Exit(code=1)
+
+
 @app.command()
 def follow(
     name: Annotated[str, typer.Argument(help="Name of agent to follow")],
@@ -903,6 +976,15 @@ def send(
         overcode send my-agent escape          # Press Escape (reject)
         overcode send my-agent --no-enter "y"  # Send "y" without Enter
     """
+    from ..session_manager import SessionManager
+    sm = SessionManager()
+
+    # Auto-wake sleeping agent (#168)
+    agent_session = sm.get_session_by_name(name)
+    if agent_session and agent_session.is_asleep:
+        sm.update_session(agent_session.id, is_asleep=False)
+        rprint(f"[dim]Woke agent '{name}' to send command[/dim]")
+
     launcher = ClaudeLauncher(session)
 
     # Join all text parts if multiple were given

{overcode-0.3.4 → overcode-0.3.6}/src/overcode/cli/jobs.py

@@ -55,7 +55,10 @@ def bash(
         rprint(f"  Linked to agent: {agent_name}")
 
     if follow:
-        launcher.attach(job.name)
+        if os.isatty(0):
+            launcher.attach(job.name)
+        else:
+            rprint(f"  [dim]No TTY — use 'overcode jobs tail {job.name}' to stream output[/dim]")
 
 
 @jobs_app.command("list")
@@ -144,6 +147,106 @@ def clear_completed():
     rprint("[green]✓[/green] Cleared completed jobs")
 
 
+@jobs_app.command("tail")
+def tail_job(
+    name: Annotated[str, typer.Argument(help="Job name to tail")],
+    lines: Annotated[Optional[int], typer.Option("--lines", "-n", help="Show last N lines and exit")] = None,
+    follow: Annotated[bool, typer.Option("--follow/--no-follow", "-f", help="Stream output until job completes")] = True,
+    poll_interval: Annotated[float, typer.Option("--poll", hidden=True)] = 0.5,
+):
+    """Stream a job's output (like tail -f). Works without a TTY.
+
+    Default: streams output until the job completes or Ctrl-C.
+    With --lines N: shows last N lines and exits.
+
+    Examples:
+        overcode jobs tail my-job
+        overcode jobs tail my-job --lines 50
+        overcode jobs tail my-job --no-follow
+    """
+    import signal
+    import sys
+    import time
+    from collections import deque
+    from ..follow_mode import _capture_pane, _find_dedup_start
+    from ..job_manager import JobManager
+    from ..status_patterns import strip_ansi
+
+    manager = JobManager()
+    job = manager.get_job_by_name(name)
+    if not job:
+        rprint(f"[red]Error: Job '{name}' not found[/red]")
+        raise typer.Exit(1)
+
+    tmux_session = job.tmux_session
+    window_name = job.tmux_window
+
+    # One-shot: capture and print last N lines
+    if lines is not None:
+        raw = _capture_pane(tmux_session, window_name, lines=lines)
+        if raw:
+            for line in raw.rstrip().split('\n'):
+                cleaned = strip_ansi(line).strip()
+                if cleaned:
+                    print(cleaned)
+        return
+
+    # Streaming mode
+    interrupted = False
+
+    def _sigint(sig, frame):
+        nonlocal interrupted
+        interrupted = True
+
+    old_handler = signal.signal(signal.SIGINT, _sigint)
+
+    recent_lines: deque = deque(maxlen=50)
+
+    try:
+        while not interrupted:
+            raw = _capture_pane(tmux_session, window_name)
+            if raw:
+                new_lines = []
+                for line in raw.rstrip().split('\n'):
+                    cleaned = strip_ansi(line).strip()
+                    new_lines.append(cleaned)
+
+                output_start = _find_dedup_start(new_lines, recent_lines)
+                if output_start < len(new_lines):
+                    for line in new_lines[output_start:]:
+                        if line:
+                            print(line)
+                        recent_lines.append(line)
+
+            # Check if job is done
+            if follow:
+                job = manager.get_job_by_name(name)
+                if job and job.status in ("completed", "failed", "killed"):
+                    # Final capture
+                    time.sleep(poll_interval)
+                    raw = _capture_pane(tmux_session, window_name)
+                    if raw:
+                        new_lines = [strip_ansi(l).strip() for l in raw.rstrip().split('\n')]
+                        output_start = _find_dedup_start(new_lines, recent_lines)
+                        for line in new_lines[output_start:]:
+                            if line:
+                                print(line)
+                            recent_lines.append(line)
+                    status_msg = f"completed (exit {job.exit_code})" if job.exit_code is not None else job.status
+                    print(f"\n[tail] Job '{name}' {status_msg}", file=sys.stderr)
+                    raise typer.Exit(0 if job.status == "completed" else 1)
+            else:
+                # --no-follow: one capture cycle then exit
+                break
+
+            time.sleep(poll_interval)
+    finally:
+        signal.signal(signal.SIGINT, old_handler)
+
+    if interrupted:
+        raise typer.Exit(130)
+
+
 @jobs_app.command("_complete", hidden=True)
 def mark_complete(
     job_id: Annotated[str, typer.Argument(help="Job ID")],

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

@@ -118,8 +118,10 @@ def get_summarizer_config() -> dict:
     default_api_url = "https://api.openai.com/v1/chat/completions"
     default_model = "gpt-4o-mini"
     default_api_key_var = "OPENAI_API_KEY"
+    default_api_type = "openai"
 
     # Config file takes precedence, env vars are fallback
+    api_type = _get_config_value("summarizer.api_type") or os.environ.get("OVERCODE_SUMMARIZER_API_TYPE") or default_api_type
     api_url = _get_config_value("summarizer.api_url") or os.environ.get("OVERCODE_SUMMARIZER_API_URL") or default_api_url
     model = _get_config_value("summarizer.model") or os.environ.get("OVERCODE_SUMMARIZER_MODEL") or default_model
     api_key_var = _get_config_value("summarizer.api_key_var") or os.environ.get("OVERCODE_SUMMARIZER_API_KEY_VAR") or default_api_key_var
@@ -127,11 +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,
     }
 
 
@@ -340,6 +351,7 @@ def get_new_agent_defaults() -> dict:
     return {
         "bypass_permissions": bool(defaults.get("bypass_permissions", False)),
         "agent_teams": bool(defaults.get("agent_teams", False)),
+        "provider": defaults.get("provider", "web"),
     }
 
 
@@ -354,6 +366,22 @@ def save_new_agent_defaults(defaults: dict) -> None:
     save_config(config)
 
 
+def get_bedrock_config() -> dict:
+    """Get AWS Bedrock configuration.
+
+    Config format in ~/.overcode/config.yaml:
+        bedrock:
+          region: us-east-1
+
+    Returns:
+        Dict with region (str).
+    """
+    bedrock = _get_config_value("bedrock", {})
+    return {
+        "region": bedrock.get("region", "us-east-1"),
+    }
+
+
 def get_jobs_retention_hours() -> float:
     """Get job retention period in hours.
 

overcode-0.3.6/src/overcode/daemon_claude_skill.md

@@ -0,0 +1,68 @@
+# Overcode Supervisor Skill
+
+You are the Overcode supervisor agent. Your mission: **Unblock each non-green session once, then exit**.
+
+## Status Guide
+
+- ORANGE (`waiting_approval`) -- Agent blocked on a permission prompt. This is your PRIMARY target. Approve or reject based on standing instructions and approval rules.
+- RED (`waiting_user`) -- Agent waiting for human input at the prompt. If it has standing instructions, send guidance. If not, skip it.
+- YELLOW (`busy_sleeping`) -- Agent is sleeping. Usually skip.
+- PURPLE (`error`) -- API error. Usually skip.
+
+## Critical: Act Fast, Don't Investigate
+
+You have LIMITED TIME. Do NOT waste it on `overcode list` or reading sessions.json -- the context below already tells you which sessions need help and their standing instructions.
+
+**For each non-green session in order:**
+
+1. Run `overcode show <name>` to see what it's stuck on
+2. Immediately act: `overcode send <name> enter` (approve) or `overcode send <name> escape` (reject)
+3. Move to the next session -- do NOT check if it worked
+
+## How to Unblock
+
+    # Approve a permission request (ORANGE sessions)
+    overcode send my-agent enter
+
+    # Reject a permission request
+    overcode send my-agent escape
+
+    # Send text response (RED sessions with instructions)
+    overcode send my-agent "your guidance here"
+
+## Approval Rules
+
+Follow the session's **standing instructions** first. Then apply these defaults:
+
+### Auto-Approve
+- File reads/writes/edits, Grep, Glob
+- Shell commands: ls, cat, head, tail, find, grep, mkdir, touch, wc, sort, diff
+- git add, git commit, git status, git diff, git log, git branch
+- Running tests, linters, builds
+- WebFetch, web searches
+- pip/npm/uv install
+
+### Use Judgment
+- git push (only if tests pass)
+- Operations outside the project directory
+- Destructive operations (rm, git reset)
+
+### Reject
+- rm -rf on large directories
+- Operations on system files
+- Network writes to external services (unless in standing instructions)
+
+## Your Process
+
+For EACH non-green session listed in the context below:
+1. `overcode show <name>` -- see what it needs
+2. Decide and act immediately
+3. Move on
+
+After attempting ALL sessions once, run `exit 0`. The daemon will call you again if needed.
+
+**Do NOT:**
+- Run `overcode list` (you already have the list)
+- Read sessions.json (you already have the context)
+- Loop back to check results
+- Make multiple attempts on the same session

{overcode-0.3.4 → 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.4 → overcode-0.3.6}/src/overcode/history_reader.py

@@ -650,8 +650,15 @@ def get_session_stats(
     interactions = hf.get_interactions_for_session(session)
     interaction_count = len(interactions)
 
-    # Derive Claude sessionIds from the already-scoped interactions
+    # Derive Claude sessionIds and their project paths from interactions.
+    # Claude Code may store session files under a different project path
+    # than start_directory (e.g., when the directory doesn't exist or Claude
+    # chooses a different project root).
     session_ids = {e.session_id for e in interactions if e.session_id}
+    sid_to_project: Dict[str, str] = {}
+    for e in interactions:
+        if e.session_id and e.project:
+            sid_to_project[e.session_id] = e.project
 
     # Active session ID for context window after /clear (#116)
     active_session_id = getattr(session, 'active_claude_session_id', None)
@@ -673,6 +680,16 @@ def get_session_stats(
         session_file = get_session_file_path(
             session.start_directory, sid, projects_path
         )
+        # Fall back to the project path from history entries if the session
+        # file doesn't exist at the expected start_directory path.  Claude
+        # Code may use a different project root (e.g. home dir) when the
+        # launch directory no longer exists.
+        if not session_file.exists():
+            alt_project = sid_to_project.get(sid)
+            if alt_project:
+                session_file = get_session_file_path(
+                    alt_project, sid, projects_path
+                )
         usage, work_times = read_session_file_stats(session_file, since=session_start)
         total_input += usage["input_tokens"]
         total_output += usage["output_tokens"]
@@ -695,7 +712,9 @@ def get_session_stats(
         all_work_times.extend(work_times)
 
         # Check for subagent files in {sessionId}/subagents/
-        encoded = encode_project_path(session.start_directory)
+        # Use the actual project path where the session file was found.
+        actual_project = sid_to_project.get(sid, session.start_directory)
+        encoded = encode_project_path(actual_project)
         subagents_dir = projects_path / encoded / sid / "subagents"
         if subagents_dir.exists():
             for subagent_file in subagents_dir.glob("agent-*.jsonl"):

{overcode-0.3.4 → overcode-0.3.6}/src/overcode/hook_handler.py

@@ -15,6 +15,7 @@ Hook registrations (all use the same command):
 import json
 import logging
 import os
+import subprocess
 import sys
 import time
 from pathlib import Path
@@ -35,6 +36,47 @@ OVERCODE_HOOKS: list[tuple[str, str]] = [
 ]
 
 
+def _detect_from_tmux_pane() -> tuple[str | None, str | None]:
+    """Detect agent name and tmux session from the current tmux pane.
+
+    Fallback for when OVERCODE_SESSION_NAME / OVERCODE_TMUX_SESSION env vars
+    are missing (e.g. after a manual session restart with --session-id).
+
+    Returns (session_name, tmux_session) or (None, None) if detection fails.
+    """
+    pane_id = os.environ.get("TMUX_PANE")
+    if not pane_id:
+        return None, None
+    try:
+        window_name = subprocess.run(
+            ["tmux", "display-message", "-p", "-t", pane_id, "#{window_name}"],
+            capture_output=True, text=True, timeout=2,
+        ).stdout.strip()
+        tmux_session = subprocess.run(
+            ["tmux", "display-message", "-p", "-t", pane_id, "#{session_name}"],
+            capture_output=True, text=True, timeout=2,
+        ).stdout.strip()
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return None, None
+
+    if not window_name or not tmux_session:
+        return None, None
+
+    # Strip oc-view- prefix from split-view session names
+    if tmux_session.startswith("oc-view-"):
+        tmux_session = tmux_session[len("oc-view-"):]
+
+    # Window names are "agentname-XXXX" where XXXX is a UUID prefix
+    # Strip the last "-XXXX" suffix to get the agent name
+    dash_idx = window_name.rfind("-")
+    if dash_idx > 0:
+        session_name = window_name[:dash_idx]
+    else:
+        session_name = window_name
+
+    return session_name, tmux_session
+
+
 def _get_hook_state_path(tmux_session: str, session_name: str) -> Path:
     """Get the path for a hook state file.
 
@@ -88,7 +130,11 @@ def handle_hook_event() -> None:
     tmux_session = os.environ.get("OVERCODE_TMUX_SESSION")
 
     if not session_name or not tmux_session:
-        return
+        # Fallback: detect from tmux pane when env vars are missing
+        # (e.g. after manual session restart with --session-id)
+        session_name, tmux_session = _detect_from_tmux_pane()
+        if not session_name or not tmux_session:
+            return
 
     # Read stdin JSON
     try:

{overcode-0.3.4 → overcode-0.3.6}/src/overcode/hook_status_detector.py

@@ -24,6 +24,7 @@ from .status_constants import (
     STATUS_CAPTURE_LINES,
     STATUS_RUNNING,
     STATUS_BUSY_SLEEPING,
+    STATUS_WAITING_APPROVAL,
     STATUS_WAITING_USER,
     STATUS_WAITING_OVERSIGHT,
     STATUS_TERMINATED,
@@ -51,7 +52,7 @@ _HOOK_STATUS_MAP = {
     "PostToolUseFailure": STATUS_RUNNING,  # Tool failed but agent is still working
     "Stop": STATUS_WAITING_USER,
     "StopFailure": STATUS_ERROR,  # API error ended the turn (purple indicator)
-    "PermissionRequest": STATUS_WAITING_USER,
+    "PermissionRequest": STATUS_WAITING_APPROVAL,
     "SessionEnd": STATUS_TERMINATED,
 }