overcode 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

overcode/__init__.py

@@ -2,4 +2,4 @@
 Overcode - A supervisor for managing multiple Claude Code instances.
 """
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"

overcode/cli.py

@@ -39,6 +39,15 @@ supervisor_daemon_app = typer.Typer(
 )
 app.add_typer(supervisor_daemon_app, name="supervisor-daemon")
 
+# Config subcommand group
+config_app = typer.Typer(
+    name="config",
+    help="Manage configuration",
+    no_args_is_help=False,
+    invoke_without_command=True,
+)
+app.add_typer(config_app, name="config")
+
 # Console for rich output
 console = Console()
 
@@ -194,6 +203,33 @@ def cleanup(session: SessionOption = "agents"):
         rprint("[dim]No terminated sessions to clean up[/dim]")
 
 
+@app.command(name="set-value")
+def set_value(
+    name: Annotated[str, typer.Argument(help="Name of agent")],
+    value: Annotated[int, typer.Argument(help="Priority value (default 1000, higher = more important)")],
+    session: SessionOption = "agents",
+):
+    """Set agent priority value for sorting (#61).
+
+    Higher values indicate higher priority. Default is 1000.
+
+    Examples:
+        overcode set-value my-agent 2000    # High priority
+        overcode set-value my-agent 500     # Low priority
+        overcode set-value my-agent 1000    # Reset to default
+    """
+    from .session_manager import SessionManager
+
+    manager = SessionManager()
+    agent = manager.get_session_by_name(name)
+    if not agent:
+        rprint(f"[red]Error: Agent '{name}' not found[/red]")
+        raise typer.Exit(code=1)
+
+    manager.set_agent_value(agent.id, value)
+    rprint(f"[green]✓ Set {name} value to {value}[/green]")
+
+
 @app.command()
 def send(
     name: Annotated[str, typer.Argument(help="Name of agent")],
@@ -771,70 +807,132 @@ def supervisor_daemon_watch(session: SessionOption = "agents"):
 
 
 # =============================================================================
-# Summarizer Commands
+# Config Commands
 # =============================================================================
 
+CONFIG_TEMPLATE = """\
+# Overcode configuration
+# Location: ~/.overcode/config.yaml
+
+# Default instructions sent to new agents
+# default_standing_instructions: "Be concise. Ask before making large changes."
+
+# AI summarizer settings (for corporate API gateways)
+# summarizer:
+#   api_url: https://api.openai.com/v1/chat/completions
+#   model: gpt-4o-mini
+#   api_key_var: OPENAI_API_KEY  # env var containing the API key
+
+# Cloud relay for remote monitoring
+# relay:
+#   enabled: false
+#   url: https://your-worker.workers.dev/update
+#   api_key: your-secret-key
+#   interval: 30  # seconds between pushes
+
+# Web dashboard time presets
+# web:
+#   time_presets:
+#     - name: "Morning"
+#       start: "09:00"
+#       end: "12:00"
+#     - name: "Full Day"
+#       start: "09:00"
+#       end: "17:00"
+"""
 
-@app.command()
-def summarizer(
-    action: Annotated[
-        str, typer.Argument(help="Action: on, off, or status")
-    ] = "status",
-    session: SessionOption = "agents",
-):
-    """Control the agent activity summarizer.
 
-    The summarizer uses GPT-4o-mini to generate human-readable summaries
-    of what each agent has been doing. Requires OPENAI_API_KEY env var.
+@config_app.callback(invoke_without_command=True)
+def config_default(ctx: typer.Context):
+    """Show current configuration (default when no subcommand given)."""
+    if ctx.invoked_subcommand is None:
+        _config_show()
 
-    Examples:
-        overcode summarizer status  # Check current state
-        overcode summarizer on      # Enable summarizer
-        overcode summarizer off     # Disable summarizer
+
+@config_app.command("init")
+def config_init(
+    force: Annotated[
+        bool, typer.Option("--force", "-f", help="Overwrite existing config file")
+    ] = False,
+):
+    """Create a config file with documented defaults.
+
+    Creates ~/.overcode/config.yaml with all options commented out.
+    Use --force to overwrite an existing config file.
     """
-    from .summarizer_component import (
-        set_summarizer_enabled,
-        is_summarizer_enabled,
-        SummarizerClient,
-    )
-    from .monitor_daemon_state import get_monitor_daemon_state
+    from .config import CONFIG_PATH
 
-    action = action.lower()
+    # Ensure directory exists
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
 
-    if action == "status":
-        # Check if API key is available
-        api_available = SummarizerClient.is_available()
-        enabled = is_summarizer_enabled(session)
+    if CONFIG_PATH.exists() and not force:
+        rprint(f"[yellow]Config file already exists:[/yellow] {CONFIG_PATH}")
+        rprint("[dim]Use --force to overwrite[/dim]")
+        raise typer.Exit(1)
 
-        # Get stats from daemon state
-        state = get_monitor_daemon_state(session)
+    CONFIG_PATH.write_text(CONFIG_TEMPLATE)
+    rprint(f"[green]✓[/green] Created config file: [bold]{CONFIG_PATH}[/bold]")
+    rprint("[dim]Edit to customize your settings[/dim]")
 
-        rprint(f"[bold]Summarizer Status ({session}):[/bold]")
-        rprint(f"  API key: {'[green]available[/green]' if api_available else '[red]not set[/red] (export OPENAI_API_KEY=...)'}")
-        rprint(f"  Enabled: {'[green]yes[/green]' if enabled else '[dim]no[/dim]'}")
 
-        if state:
-            rprint(f"  API calls: {state.summarizer_calls}")
-            rprint(f"  Est. cost: ${state.summarizer_cost_usd:.4f}")
+@config_app.command("show")
+def config_show():
+    """Show current configuration."""
+    _config_show()
 
-    elif action == "on":
-        if not SummarizerClient.is_available():
-            rprint("[red]Error:[/red] OPENAI_API_KEY environment variable not set")
-            rprint("[dim]Export your API key: export OPENAI_API_KEY='sk-...'[/dim]")
-            raise typer.Exit(1)
 
-        set_summarizer_enabled(session, True)
-        rprint(f"[green]✓[/green] Summarizer enabled for session '{session}'")
-        rprint("[dim]Summaries will appear in the web dashboard and TUI[/dim]")
+def _config_show():
+    """Internal function to display current config."""
+    from .config import CONFIG_PATH, load_config
 
-    elif action == "off":
-        set_summarizer_enabled(session, False)
-        rprint(f"[green]✓[/green] Summarizer disabled for session '{session}'")
+    if not CONFIG_PATH.exists():
+        rprint(f"[dim]No config file found at {CONFIG_PATH}[/dim]")
+        rprint("[dim]Run 'overcode config init' to create one[/dim]")
+        return
 
-    else:
-        rprint(f"[red]Unknown action:[/red] {action}")
-        rprint("[dim]Use: on, off, or status[/dim]")
-        raise typer.Exit(1)
+    config = load_config()
+    if not config:
+        rprint(f"[dim]Config file is empty: {CONFIG_PATH}[/dim]")
+        return
+
+    rprint(f"[bold]Configuration[/bold] ({CONFIG_PATH}):\n")
+
+    # Show each configured section
+    if "default_standing_instructions" in config:
+        instr = config["default_standing_instructions"]
+        display = instr[:60] + "..." if len(instr) > 60 else instr
+        rprint(f"  default_standing_instructions: \"{display}\"")
+
+    if "summarizer" in config:
+        s = config["summarizer"]
+        rprint("  summarizer:")
+        if "api_url" in s:
+            rprint(f"    api_url: {s['api_url']}")
+        if "model" in s:
+            rprint(f"    model: {s['model']}")
+        if "api_key_var" in s:
+            rprint(f"    api_key_var: {s['api_key_var']}")
+
+    if "relay" in config:
+        r = config["relay"]
+        rprint("  relay:")
+        rprint(f"    enabled: {r.get('enabled', False)}")
+        if "url" in r:
+            rprint(f"    url: {r['url']}")
+        if "interval" in r:
+            rprint(f"    interval: {r['interval']}s")
+
+    if "web" in config:
+        w = config["web"]
+        if "time_presets" in w:
+            rprint(f"  web.time_presets: {len(w['time_presets'])} presets")
+
+
+@config_app.command("path")
+def config_path():
+    """Show the config file path."""
+    from .config import CONFIG_PATH
+    print(CONFIG_PATH)
 
 
 # =============================================================================

overcode/config.py

@@ -72,6 +72,72 @@ def get_relay_config() -> Optional[dict]:
     }
 
 
+def get_summarizer_config() -> dict:
+    """Get summarizer configuration for AI summaries.
+
+    Config file takes precedence, environment variables are fallback.
+
+    Config format in ~/.overcode/config.yaml:
+        summarizer:
+          api_url: https://api.openai.com/v1/chat/completions
+          model: gpt-4o-mini
+          api_key_var: OPENAI_API_KEY  # env var name containing the key
+
+    Environment variable fallbacks:
+        OVERCODE_SUMMARIZER_API_URL
+        OVERCODE_SUMMARIZER_MODEL
+        OVERCODE_SUMMARIZER_API_KEY_VAR
+
+    Returns:
+        Dict with api_url, model, and api_key (resolved from env var)
+    """
+    import os
+
+    # Defaults
+    default_api_url = "https://api.openai.com/v1/chat/completions"
+    default_model = "gpt-4o-mini"
+    default_api_key_var = "OPENAI_API_KEY"
+
+    config = load_config()
+    summarizer = config.get("summarizer", {})
+
+    # Config file takes precedence, env vars are fallback
+    api_url = summarizer.get("api_url") or os.environ.get("OVERCODE_SUMMARIZER_API_URL") or default_api_url
+    model = summarizer.get("model") or os.environ.get("OVERCODE_SUMMARIZER_MODEL") or default_model
+    api_key_var = summarizer.get("api_key_var") or os.environ.get("OVERCODE_SUMMARIZER_API_KEY_VAR") or default_api_key_var
+
+    # Resolve the actual API key from the configured env var
+    api_key = os.environ.get(api_key_var)
+
+    return {
+        "api_url": api_url,
+        "model": model,
+        "api_key": api_key,
+        "api_key_var": api_key_var,
+    }
+
+
+def get_timeline_config() -> dict:
+    """Get timeline display configuration.
+
+    Config format in ~/.overcode/config.yaml:
+        timeline:
+          hours: 3.0  # How many hours of history to show
+
+    Returns:
+        Dict with timeline settings (hours)
+    """
+    default_hours = 3.0
+
+    config = load_config()
+    timeline = config.get("timeline", {})
+    hours = timeline.get("hours", default_hours)
+
+    return {
+        "hours": hours,
+    }
+
+
 def get_web_time_presets() -> list:
     """Get time presets for the web analytics dashboard.
 

overcode/daemon_claude_skill.md

@@ -1,17 +1,16 @@
 # Overcode Supervisor Skill
 
-You are the Overcode supervisor agent. Your mission: **Make all RED sessions GREEN**.
+You are the Overcode supervisor agent. Your mission: **Attempt to unblock each RED session once, then exit**.
 
 ## Your Role
 
-You monitor and unblock Claude agent sessions running in tmux. When sessions get stuck (RED status), you help them make progress by:
+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 autopilot instructions
+- Making decisions based on their standing instructions
 - Approving safe permission requests
 - Sending guidance or clarifying information
-- Having multi-turn conversations with agents
 
-**When all sessions are GREEN, your job is done - exit successfully.**
+**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.**
 
 ## How to Control Sessions (Recommended)
 
@@ -115,35 +114,32 @@ You must follow these rules when deciding to approve operations:
 # 1. Read current session states
 cat ~/.overcode/sessions/sessions.json | jq '.[] | {name, tmux_window, standing_instructions, stats}'
 
-# 2. Find RED sessions
-# Check TUI or parse status
-
-# 3. For each RED session, read output
-tmux capture-pane -t agents:1 -p -S -100
-
-# 4. Make decision based on:
-#    - What they're stuck on
-#    - Their autopilot instruction
-#    - Approval rules
+# 2. Find RED sessions (use overcode list)
+overcode list
 
-# 5a. If permission request is safe, approve:
-tmux send-keys -t agents:1 "" C-m
+# 3. For EACH RED session, make ONE attempt:
 
-# 5b. If they need guidance, send message:
-tmux send-keys -t agents:1 "Focus on the core feature first, implement error handling later." C-m
+#    a. Read output to understand what they're stuck on
+overcode show agent-name --lines 100
 
-# 5c. If permission unsafe, reject:
-tmux send-keys -t agents:1 Escape
+#    b. Make decision based on:
+#       - What they're stuck on
+#       - Their standing instructions
+#       - Approval rules below
 
-# 6. Log your action
-echo "$(date): Approved Write permission for recipe-book session (within working dir)" >> ~/.overcode/supervisor.log
+#    c. Take action:
+overcode send agent-name enter      # Approve permission
+overcode send agent-name escape     # Reject permission
+overcode send agent-name "guidance" # Send instructions
 
-# 7. Repeat for other RED sessions
+#    d. Move to next RED session immediately (don't wait)
 
-# 8. When all GREEN, exit
+# 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
@@ -168,13 +164,20 @@ echo "$(date): recipe-book - Approved write to desserts.md (within working dir,
 
 ## Your Process
 
-1. **Survey** - Read all session states from sessions.json
-2. **Identify** - Find RED sessions (waiting for user)
-3. **Investigate** - Read their tmux output to see what they're stuck on
-4. **Decide** - Apply approval rules and autopilot context
-5. **Act** - Send tmux commands to unblock them
-6. **Log** - Record your decisions
-7. **Repeat** - Check if more sessions need help
-8. **Exit** - When all GREEN, your job is complete
+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`
+
+**Do NOT:**
+- Loop back to check if sessions turned green
+- Wait to see if your action worked
+- 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/history_reader.py

@@ -202,6 +202,44 @@ def get_session_ids_for_session(
     return sorted(session_ids)
 
 
+def get_current_session_id_for_directory(
+    directory: str,
+    since: datetime,
+    history_path: Path = CLAUDE_HISTORY_PATH
+) -> Optional[str]:
+    """Get the most recent Claude sessionId for a directory since a given time.
+
+    This is used to discover new Claude sessionIds that should be tracked
+    by an overcode agent running in that directory (#119).
+
+    Args:
+        directory: The project directory path
+        since: Only consider entries after this time
+        history_path: Path to history file
+
+    Returns:
+        The most recent sessionId, or None if no matching entries
+    """
+    entries = read_history(history_path)
+    session_dir = str(Path(directory).resolve())
+    since_ms = int(since.timestamp() * 1000)
+
+    latest_session_id = None
+    latest_timestamp = 0
+
+    for entry in entries:
+        if entry.timestamp_ms < since_ms:
+            continue
+        if entry.project:
+            entry_dir = str(Path(entry.project).resolve())
+            if entry_dir == session_dir and entry.session_id:
+                if entry.timestamp_ms > latest_timestamp:
+                    latest_timestamp = entry.timestamp_ms
+                    latest_session_id = entry.session_id
+
+    return latest_session_id
+
+
 def encode_project_path(path: str) -> str:
     """Encode a project path to Claude Code's directory naming format.
 
@@ -397,6 +435,10 @@ def get_session_stats(
 
     Combines interaction counting with token usage from session files.
 
+    For context window calculation, only owned sessionIds are used to avoid
+    cross-contamination when multiple agents run in the same directory (#119).
+    Total token counting still uses all matched sessionIds.
+
     Args:
         session: The overcode Session
         history_path: Path to history.jsonl
@@ -418,21 +460,25 @@ def get_session_stats(
     interactions = get_interactions_for_session(session, history_path)
     interaction_count = len(interactions)
 
-    # Get unique session IDs
-    session_ids = set()
+    # Get unique session IDs from interactions (for total token counting)
+    all_session_ids = set()
     for entry in interactions:
         if entry.session_id:
-            session_ids.add(entry.session_id)
+            all_session_ids.add(entry.session_id)
+
+    # Get owned sessionIds for context calculation (#119)
+    # Only use explicitly tracked sessionIds to avoid showing wrong agent's context
+    owned_session_ids = getattr(session, 'claude_session_ids', None) or []
 
     # Sum token usage and work times across all session files
     total_input = 0
     total_output = 0
     total_cache_creation = 0
     total_cache_read = 0
-    current_context = 0  # Track most recent context size
+    current_context = 0  # Track most recent context size (only from owned sessions)
     all_work_times: List[float] = []
 
-    for sid in session_ids:
+    for sid in all_session_ids:
         session_file = get_session_file_path(
             session.start_directory, sid, projects_path
         )
@@ -441,14 +487,29 @@ def get_session_stats(
         total_output += usage["output_tokens"]
         total_cache_creation += usage["cache_creation_tokens"]
         total_cache_read += usage["cache_read_tokens"]
-        # Keep the largest current context (most recent across all session files)
-        if usage["current_context_tokens"] > current_context:
-            current_context = usage["current_context_tokens"]
+
+        # Only track context from OWNED sessionIds to avoid cross-contamination (#119)
+        if sid in owned_session_ids:
+            if usage["current_context_tokens"] > current_context:
+                current_context = usage["current_context_tokens"]
 
         # 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/
+        encoded = encode_project_path(session.start_directory)
+        subagents_dir = projects_path / encoded / sid / "subagents"
+        if subagents_dir.exists():
+            for subagent_file in subagents_dir.glob("agent-*.jsonl"):
+                sub_usage = read_token_usage_from_session_file(
+                    subagent_file, since=session_start
+                )
+                total_input += sub_usage["input_tokens"]
+                total_output += sub_usage["output_tokens"]
+                total_cache_creation += sub_usage["cache_creation_tokens"]
+                total_cache_read += sub_usage["cache_read_tokens"]
+
     return ClaudeSessionStats(
         interaction_count=interaction_count,
         input_tokens=total_input,