overcode 0.3.3__tar.gz → 0.3.5__tar.gz

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

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

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

{overcode-0.3.3 → overcode-0.3.5}/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
 ```
 
@@ -248,6 +251,32 @@ Jobs are visible in the TUI jobs view (press `J`) and auto-clean after 24h (conf
 }
 
 
+def get_available_skills(project_dir: str | None = None) -> list[str]:
+    """Scan for installed skill directories (user-level + project-level).
+
+    Returns sorted list of skill names found in ~/.claude/skills/
+    and optionally .claude/skills/ relative to project_dir.
+    """
+    skills: set[str] = set()
+
+    # User-level skills
+    user_skills = Path.home() / ".claude" / "skills"
+    if user_skills.is_dir():
+        for d in user_skills.iterdir():
+            if d.is_dir() and (d / "SKILL.md").exists():
+                skills.add(d.name)
+
+    # Project-level skills
+    if project_dir:
+        proj_skills = Path(project_dir) / ".claude" / "skills"
+        if proj_skills.is_dir():
+            for d in proj_skills.iterdir():
+                if d.is_dir() and (d / "SKILL.md").exists():
+                    skills.add(d.name)
+
+    return sorted(skills)
+
+
 def any_skills_stale() -> bool:
     """Check if any installed skills are outdated vs bundled versions."""
     base = Path.home() / ".claude" / "skills"

{overcode-0.3.3 → overcode-0.3.5}/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.3 → overcode-0.3.5}/src/overcode/cli/config.py

@@ -44,8 +44,8 @@ CONFIG_TEMPLATE = """\
 #       start: "09:00"
 #       end: "17:00"
 
-# Time context hook settings (for 'overcode time-context')
-# time_context:
+# Enhanced context hook settings (agent identity, clock, presence, uptime)
+# enhanced_context:
 #   office_start: 9
 #   office_end: 17
 #   heartbeat_interval_minutes: 15  # omit to disable

{overcode-0.3.3 → overcode-0.3.5}/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.3 → overcode-0.3.5}/src/overcode/cli/monitoring.py

@@ -18,7 +18,7 @@ def hook_handler_cmd():
 
     Called by Claude Code hooks, not by users directly.
     Reads event JSON from stdin, writes state for status detection,
-    and outputs time-context for UserPromptSubmit events.
+    and outputs enhanced context for UserPromptSubmit events.
     """
     from ..hook_handler import handle_hook_event
 

{overcode-0.3.3 → overcode-0.3.5}/src/overcode/cli/split.py

@@ -263,20 +263,51 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
     # --- Scrollback for the nested tmux in the bottom pane ---
     # The bottom pane runs a nested tmux client. The outer tmux
     # intercepts the prefix key, so copy-mode can't be entered
-    # normally. These bindings use `copy-mode -t` to directly enter
-    # copy mode in the inner session via the tmux API.
+    # normally.
+    #
+    # For local agents: use `copy-mode -t` to directly enter copy mode
+    # in the inner session via the tmux API (the linked session shares
+    # the actual agent panes, so scrollback is real).
+    #
+    # For SSH proxy windows (name starts with "ssh:"): the linked
+    # session pane is an SSH+tmux-attach client whose local scrollback
+    # is just rendering frames. Instead, forward PageUp/scroll through
+    # to the remote tmux which has the actual agent scrollback.
     if linked_session:
         # PageUp: enter copy mode + scroll up, but only when in the
         # bottom pane (pane_index != base) of the split window.
         # Top pane (Textual TUI) and other windows get normal PageUp.
+        #
+        # For SSH proxy windows: forward PageUp through the SSH pane
+        # so the *remote* tmux enters copy mode (the local proxy pane
+        # has no real scrollback — just rendered inner-tmux frames).
+        # For local agents: enter copy mode directly on the linked
+        # session which shares the real agent pane.
+        #
+        # Detection uses the @is_ssh_proxy window option (set by
+        # create_ssh_proxy_window) via a shell-based if-shell — this
+        # avoids tmux format expansion issues in stored bindings.
+        _ssh_check = (
+            f"tmux show-window-option -t {linked_session} -v @is_ssh_proxy "
+            "2>/dev/null | grep -q on"
+        )
         _tmux(
             "bind-key", "-n", "PPage",
             "if-shell", "-F",
             f"#{{&&:#{{==:#{{window_name}},{SPLIT_WINDOW_NAME}}},#{{!=:#{{pane_index}},{_base}}}}}",
-            f"copy-mode -t {linked_session} -u",
+            # SSH proxy: send prefix + PPage so the REMOTE tmux enters
+            # copy mode (the remote's root-table PPage is overridden by
+            # overcode, but prefix PPage still maps to copy-mode -u).
+            # Local: enter copy mode directly on the linked session.
+            f'if-shell "{_ssh_check}" '
+            f'"send-keys -t {linked_session} C-b ; '
+            f'send-keys -t {linked_session} PPage" '
+            f'"copy-mode -t {linked_session} -u"',
             "send-keys PPage",
         )
         # PageDown in the inner session's copy mode
+        # (send-keys works for both local and SSH proxy — for local it
+        # controls copy mode, for SSH proxy it forwards to remote tmux)
         _tmux(
             "bind-key", "-n", "NPage",
             "if-shell", "-F",
@@ -288,8 +319,9 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
         # Without this, scrolling enters copy mode in the outer pane
         # which has no scrollback (just rendered inner tmux frames).
         #
-        # Strategy: enter copy mode in the inner session (no-op if
-        # already active), then send scroll-up/down commands to it.
+        # For local agents: enter copy mode in the inner session then
+        # send scroll commands. For SSH proxies: forward mouse events
+        # to the remote tmux through the pane.
         _in_bottom = (
             f"#{{&&:#{{==:#{{window_name}},{SPLIT_WINDOW_NAME}}},"
             f"#{{!=:#{{pane_index}},{_base}}}}}"
@@ -297,8 +329,14 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
         _tmux(
             "bind-key", "-n", "WheelUpPane",
             "if-shell", "-F", _in_bottom,
-            f"copy-mode -t {linked_session} -e ; "
-            f"send-keys -t {linked_session} -X -N 3 scroll-up",
+            # SSH proxy: send prefix+PPage to enter copy mode on remote
+            # (no-op if already in copy mode, then PPage scrolls up).
+            # Local: enter copy mode + scroll up directly.
+            f'if-shell "{_ssh_check}" '
+            f'"send-keys -t {linked_session} C-b ; '
+            f'send-keys -t {linked_session} PPage" '
+            f'"copy-mode -t {linked_session} -e ; '
+            f'send-keys -t {linked_session} -X -N 3 scroll-up"',
             # Default behaviour for other contexts
             "if-shell -F '#{||:#{pane_in_mode},#{mouse_any_flag}}' "
             "'send-keys -M' 'copy-mode -e'",
@@ -306,7 +344,11 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
         _tmux(
             "bind-key", "-n", "WheelDownPane",
             "if-shell", "-F", _in_bottom,
-            f"send-keys -t {linked_session} -X -N 3 scroll-down",
+            # SSH proxy: send NPage to remote (works in copy mode).
+            # Local: send scroll-down in local copy mode.
+            f'if-shell "{_ssh_check}" '
+            f'"send-keys -t {linked_session} NPage" '
+            f'"send-keys -t {linked_session} -X -N 3 scroll-down"',
             "send-keys -M",
         )
 

{overcode-0.3.3 → overcode-0.3.5}/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
@@ -128,6 +130,7 @@ def get_summarizer_config() -> dict:
     api_key = os.environ.get(api_key_var)
 
     return {
+        "api_type": api_type,
         "api_url": api_url,
         "model": model,
         "api_key": api_key,
@@ -197,23 +200,35 @@ def get_web_time_presets() -> list:
     ]
 
 
-def get_time_context_config() -> dict:
-    """Get time context configuration for the time-context hook.
+def get_enhanced_context_config() -> dict:
+    """Get enhanced context configuration for the enhanced-context hook.
 
     Config format in ~/.overcode/config.yaml:
-        time_context:
+        enhanced_context:
           office_start: 9
           office_end: 17
           heartbeat_interval_minutes: 15  # omit to disable
 
+    Falls back to legacy 'time_context' key for backwards compatibility.
+
     Returns:
         Dict with office_start (int), office_end (int),
         heartbeat_interval_minutes (Optional[int])
     """
+    # Try new key first, fall back to legacy key
+    office_start = _get_config_value("enhanced_context.office_start")
+    if office_start is None:
+        office_start = _get_config_value("time_context.office_start", 9)
+    office_end = _get_config_value("enhanced_context.office_end")
+    if office_end is None:
+        office_end = _get_config_value("time_context.office_end", 17)
+    hb_interval = _get_config_value("enhanced_context.heartbeat_interval_minutes")
+    if hb_interval is None:
+        hb_interval = _get_config_value("time_context.heartbeat_interval_minutes")
     return {
-        "office_start": _get_config_value("time_context.office_start", 9),
-        "office_end": _get_config_value("time_context.office_end", 17),
-        "heartbeat_interval_minutes": _get_config_value("time_context.heartbeat_interval_minutes"),
+        "office_start": office_start,
+        "office_end": office_end,
+        "heartbeat_interval_minutes": hb_interval,
     }
 
 
@@ -328,6 +343,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"),
     }
 
 
@@ -342,6 +358,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.
 
@@ -365,9 +397,11 @@ def get_sisters_config() -> List[dict]:
           - name: "desktop"
             url: "http://localhost:25337"
             api_key: "secret"
+            ssh: "user@desktop"        # optional: enables tmux attach + auto-provisioning
+            tmux_session: "agents"     # optional: remote tmux session name (default: "agents")
 
     Returns:
-        List of dicts with name, url, and optional api_key. Empty list if unconfigured.
+        List of dicts with name, url, and optional api_key/ssh/tmux_session. Empty list if unconfigured.
     """
     sisters = _get_config_value("sisters", [])
     if not isinstance(sisters, list):
@@ -385,6 +419,13 @@ def get_sisters_config() -> List[dict]:
         api_key = s.get("api_key")
         if api_key:
             entry["api_key"] = api_key
+        # SSH connectivity (optional)
+        ssh = s.get("ssh")
+        if ssh:
+            entry["ssh"] = ssh
+        tmux_session = s.get("tmux_session")
+        if tmux_session:
+            entry["tmux_session"] = tmux_session
         result.append(entry)
 
     return result

overcode-0.3.5/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