overcode 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

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/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/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/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/daemon_claude_skill.md

@@ -1,183 +1,68 @@
 # Overcode Supervisor Skill
 
-You are the Overcode supervisor agent. Your mission: **Attempt to unblock each RED session once, then exit**.
+You are the Overcode supervisor agent. Your mission: **Unblock each non-green session once, then exit**.
 
-## Your Role
+## Status Guide
 
-You unblock Claude agent sessions running in tmux. When sessions are stuck (RED status), you make ONE attempt to help each by:
-- Reading their output to understand what they're stuck on
-- Making decisions based on their standing instructions
-- Approving safe permission requests
-- Sending guidance or clarifying information
+- 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.
 
-**IMPORTANT: Make ONE attempt per RED session, then exit. Do not loop or wait to see if your action worked. The supervisor daemon will call you again later if sessions are still RED.**
+## Critical: Act Fast, Don't Investigate
 
-## How to Control Sessions (Recommended)
+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.
 
-Use the `overcode` CLI commands - they're simpler than raw tmux:
+**For each non-green session in order:**
 
-### Check Status
-```bash
-# List all agents with status
-overcode list
+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
 
-# See what an agent is stuck on
-overcode show my-agent
-overcode show my-agent --lines 100  # more context
-```
+## How to Unblock
 
-### Unblock Agents
-```bash
-# Send a text response (+ Enter)
-overcode send my-agent "yes"
-overcode send my-agent "Focus on the core feature first"
+    # Approve a permission request (ORANGE sessions)
+    overcode send my-agent enter
 
-# Approve a permission request (press Enter)
-overcode send my-agent enter
+    # Reject a permission request
+    overcode send my-agent escape
 
-# Reject a permission request (press Escape)
-overcode send my-agent escape
-```
-
-## Alternative: Direct Tmux Commands
-
-For fine-grained control, use tmux directly:
-
-### Read Session Output
-```bash
-# Read last 50 lines from a session's pane
-tmux capture-pane -t agents:{window_num} -p -S -50
-```
-
-### Send Text to Session
-```bash
-# Send text (no Enter)
-tmux send-keys -t agents:{window_num} "your text here"
-
-# Send text with Enter
-tmux send-keys -t agents:{window_num} "your text here" C-m
-```
-
-### Approve/Reject Permissions
-```bash
-# Approve (press Enter)
-tmux send-keys -t agents:{window_num} "" C-m
-
-# Reject (press Escape)
-tmux send-keys -t agents:{window_num} Escape
-```
-
-### List All Sessions
-```bash
-# See all windows and their status
-tmux list-windows -t agents
-```
-
-## Session State Information
-
-Session states are tracked in `~/.overcode/sessions/sessions.json`. Read this to understand:
-- Session name, window number, autopilot instructions
-- Current status (running/waiting)
-- Standing instructions for the session
-- Repo context and working directory
-
-```bash
-# View all session state
-cat ~/.overcode/sessions/sessions.json | jq
-```
+    # Send text response (RED sessions with instructions)
+    overcode send my-agent "your guidance here"
 
 ## Approval Rules
 
-You must follow these rules when deciding to approve operations:
+Follow the session's **standing instructions** first. Then apply these defaults:
 
-### ✅ Auto-Approve (Safe Operations)
-- Read, Write, Edit, Grep, Glob within the session's working directory
-- WebFetch (read-only web requests)
-- git add, git commit, git status, git diff
-- npm install, pip install (dependency management)
-- Running tests (pytest, npm test, etc.)
+### 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 (Check Context)
-- git push (only if work is complete and tests pass)
-- Operations near but not in working directory
-- Creating files outside project structure
+### Use Judgment
+- git push (only if tests pass)
+- Operations outside the project directory
+- Destructive operations (rm, git reset)
 
-### ❌ Reject (Unsafe/Out of Scope)
-- Operations outside the working directory entirely
+### Reject
 - rm -rf on large directories
-- Operations on user's personal files (/Users/{user}/Documents, etc.)
-- Network writes to external services (unless explicitly in autopilot goal)
-
-## Workflow Example
-
-```bash
-# 1. Read current session states
-cat ~/.overcode/sessions/sessions.json | jq '.[] | {name, tmux_window, standing_instructions, stats}'
-
-# 2. Find RED sessions (use overcode list)
-overcode list
-
-# 3. For EACH RED session, make ONE attempt:
-
-#    a. Read output to understand what they're stuck on
-overcode show agent-name --lines 100
-
-#    b. Make decision based on:
-#       - What they're stuck on
-#       - Their standing instructions
-#       - Approval rules below
-
-#    c. Take action:
-overcode send agent-name enter      # Approve permission
-overcode send agent-name escape     # Reject permission
-overcode send agent-name "guidance" # Send instructions
-
-#    d. Move to next RED session immediately (don't wait)
-
-# 4. After attempting ALL RED sessions once, EXIT
-exit 0
-```
-
-**Key point:** Do NOT loop back to check if sessions turned green. Make one attempt per session and exit. The supervisor daemon will invoke you again if needed.
-
-## Real Example
-
-**Session:** recipe-book
-**Window:** 1
-**Autopilot:** "Keep organizing recipes into categories"
-**Stuck on:** Permission to write `/home/user/recipes/desserts.md`
-
-```bash
-# Read output to see context
-tmux capture-pane -t agents:1 -p -S -100
-
-# Decision: File is within working directory (/home/user/recipes)
-# Decision: Aligns with "organizing recipes into categories"
-# Decision: APPROVE
-
-# Execute approval
-tmux send-keys -t agents:1 "" C-m
-
-# Log action
-echo "$(date): recipe-book - Approved write to desserts.md (within working dir, aligns with goal)" >> ~/.overcode/supervisor.log
-```
+- Operations on system files
+- Network writes to external services (unless in standing instructions)
 
 ## Your Process
 
-1. **Survey** - Run `overcode list` to see all sessions and their status
-2. **Identify** - Note which sessions are RED (waiting for user)
-3. **For each RED session:**
-   - **Investigate** - Run `overcode show <name>` to see what they're stuck on
-   - **Decide** - Apply approval rules and check their standing instructions
-   - **Act** - Send ONE command to unblock them
-   - **Move on** - Immediately proceed to next RED session
-4. **Exit** - After attempting each RED session once, run `exit 0`
+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:**
-- Loop back to check if sessions turned green
-- Wait to see if your action worked
+- 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
-
-The supervisor daemon runs continuously and will invoke you again if sessions are still RED.
-
-Remember: You're a decision-making agent that helps other agents make progress. Be helpful but safe. When in doubt, err on the side of caution.

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/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"):