overcode 0.1.6__tar.gz → 0.1.7__tar.gz

{overcode-0.1.6/src/overcode.egg-info → overcode-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overcode
-Version: 0.1.6
+Version: 0.1.7
 Summary: A supervisor for managing multiple Claude Code instances in tmux
 Author: Mike Bond
 Project-URL: Homepage, https://github.com/mkb23/overcode

{overcode-0.1.6 → overcode-0.1.7}/pyproject.toml

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

{overcode-0.1.6 → overcode-0.1.7}/src/overcode/claude_config.py

@@ -88,3 +88,52 @@ class ClaudeConfigEditor:
 
         self.save(updated)
         return True
+
+    def remove_hook(self, event: str, command: str) -> bool:
+        """Remove a matcher group containing this command.
+
+        Returns True if found and removed, False if not found.
+        Cleans up empty event arrays and empty hooks dict.
+        """
+        settings = self.load()
+        hooks_dict = settings.get("hooks", {})
+        event_list = hooks_dict.get(event, [])
+
+        # Find the matcher group index containing this command
+        index_to_remove = None
+        for i, entry in enumerate(event_list):
+            for hook in entry.get("hooks", []):
+                if hook.get("command") == command:
+                    index_to_remove = i
+                    break
+            if index_to_remove is not None:
+                break
+
+        if index_to_remove is None:
+            return False
+
+        updated = copy.deepcopy(settings)
+        del updated["hooks"][event][index_to_remove]
+
+        # Clean up empty event array
+        if not updated["hooks"][event]:
+            del updated["hooks"][event]
+
+        # Clean up empty hooks dict
+        if not updated["hooks"]:
+            del updated["hooks"]
+
+        self.save(updated)
+        return True
+
+    def list_hooks_matching(self, command_prefix: str) -> list[tuple[str, str]]:
+        """Return [(event, command)] for all hooks whose command starts with prefix."""
+        settings = self.load()
+        results = []
+        for event, entries in settings.get("hooks", {}).items():
+            for entry in entries:
+                for hook in entry.get("hooks", []):
+                    cmd = hook.get("command", "")
+                    if cmd.startswith(command_prefix):
+                        results.append((event, cmd))
+        return results

{overcode-0.1.6 → overcode-0.1.7}/src/overcode/cli.py

@@ -40,6 +40,14 @@ supervisor_daemon_app = typer.Typer(
 )
 app.add_typer(supervisor_daemon_app, name="supervisor-daemon")
 
+# Hooks subcommand group
+hooks_app = typer.Typer(
+    name="hooks",
+    help="Manage Claude Code hook integration.",
+    no_args_is_help=True,
+)
+app.add_typer(hooks_app, name="hooks")
+
 # Config subcommand group
 config_app = typer.Typer(
     name="config",
@@ -128,12 +136,11 @@ def launch(
 @app.command("list")
 def list_agents(session: SessionOption = "agents"):
     """List running agents with status."""
-    from .status_detector import StatusDetector
-    from .history_reader import get_session_stats
     from .tui_helpers import (
         calculate_uptime, format_duration, format_tokens,
         get_current_state_times, get_status_symbol
     )
+    from .monitor_daemon_state import get_monitor_daemon_state
 
     launcher = ClaudeLauncher(session)
     sessions = launcher.list_sessions()
@@ -142,17 +149,39 @@ def list_agents(session: SessionOption = "agents"):
         rprint("[dim]No running agents[/dim]")
         return
 
-    status_detector = StatusDetector(session)
+    # Prefer daemon state for status/activity (single source of truth)
+    daemon_state = get_monitor_daemon_state(session)
+    use_daemon = daemon_state is not None and not daemon_state.is_stale()
+
+    # Only create detector as fallback when daemon isn't running
+    detector = None
+    if not use_daemon:
+        from .status_detector_factory import StatusDetectorDispatcher
+        detector = StatusDetectorDispatcher(session)
+
     terminated_count = 0
 
     for sess in sessions:
-        # For terminated sessions, use stored status; otherwise detect from tmux
         if sess.status == "terminated":
             status = "terminated"
             activity = "(tmux window no longer exists)"
             terminated_count += 1
+        elif use_daemon:
+            ds = daemon_state.get_session_by_name(sess.name)
+            if ds:
+                status = ds.current_status
+                activity = ds.current_activity
+            else:
+                # Session not yet in daemon state — detect directly
+                if detector is None:
+                    from .status_detector_factory import StatusDetectorDispatcher
+                    detector = StatusDetectorDispatcher(session)
+                status, activity, _ = detector.detect_status(sess)
         else:
-            status, activity, _ = status_detector.detect_status(sess)
+            status, activity, _ = detector.detect_status(sess)
+
+        if sess.is_asleep:
+            status = "asleep"
 
         symbol, _ = get_status_symbol(status)
 
@@ -162,10 +191,10 @@ def list_agents(session: SessionOption = "agents"):
         # Get state times using shared helper
         green_time, non_green_time, sleep_time = get_current_state_times(sess.stats, is_asleep=sess.is_asleep)
 
-        # Get stats from Claude Code history and session files
-        stats = get_session_stats(sess)
-        if stats:
-            stats_display = f"{stats.interaction_count:>2}i {format_tokens(stats.total_tokens):>5}"
+        # Stats from session manager (already synced by daemon)
+        stats = sess.stats
+        if stats.interaction_count > 0:
+            stats_display = f"{stats.interaction_count:>2}i {format_tokens(stats.input_tokens + stats.output_tokens):>5}"
         else:
             stats_display = " -i     -"
 
@@ -279,6 +308,40 @@ def set_budget(
         rprint(f"[green]✓ Cleared budget for {name}[/green]")
 
 
+@app.command()
+def annotate(
+    name: Annotated[str, typer.Argument(help="Name of agent")],
+    text: Annotated[
+        Optional[List[str]], typer.Argument(help="Annotation text (omit to clear)")
+    ] = None,
+    session: SessionOption = "agents",
+):
+    """Set or clear a human annotation on an agent (#223).
+
+    Allows programmatic annotation of agents so scripts and other tools
+    can communicate status to the overcode TUI.
+
+    Examples:
+        overcode annotate my-agent "Working on auth module"
+        overcode annotate my-agent Building the API layer
+        overcode annotate my-agent                           # Clear annotation
+    """
+    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)
+
+    annotation = " ".join(text) if text else ""
+    manager.set_human_annotation(agent.id, annotation)
+    if annotation:
+        rprint(f"[green]✓ Annotation set for {name}:[/green] {annotation}")
+    else:
+        rprint(f"[green]✓ Annotation cleared for {name}[/green]")
+
+
 @app.command()
 def send(
     name: Annotated[str, typer.Argument(help="Name of agent")],
@@ -336,14 +399,10 @@ def show(
     session: SessionOption = "agents",
 ):
     """Show agent details and recent output."""
-    from .status_detector import StatusDetector
     from .history_reader import get_session_stats
     from .status_patterns import extract_background_bash_count, extract_live_subagent_count, strip_ansi
-    from .tui_helpers import (
-        calculate_uptime, format_duration, format_tokens, format_cost,
-        format_line_count, get_current_state_times, get_status_symbol,
-        get_git_diff_stats,
-    )
+    from .tui_helpers import get_git_diff_stats
+    from .summary_columns import build_cli_context, render_cli_stats
     from .monitor_daemon_state import get_monitor_daemon_state
 
     launcher = ClaudeLauncher(session)
@@ -354,18 +413,39 @@ def show(
         rprint(f"[red]✗[/red] Agent '[bold]{name}[/bold]' not found")
         raise typer.Exit(1)
 
-    # Detect live status (gets status + pane content with ANSI for bash count)
+    # Read daemon state for status/activity (single source of truth)
+    daemon_state = get_monitor_daemon_state(session)
+    daemon_session = None
+    if daemon_state and not daemon_state.is_stale():
+        daemon_session = daemon_state.get_session_by_name(name)
+
+    # Get status/activity from daemon state, falling back to detection
     pane_content_raw = ""
     if sess.status == "terminated":
         status = "terminated"
         activity = "(tmux window no longer exists)"
+    elif daemon_session:
+        status = daemon_session.current_status
+        activity = daemon_session.current_activity
     else:
-        status_detector = StatusDetector(session)
-        status, activity, pane_content_raw = status_detector.detect_status(sess)
+        # Daemon not running — fall back to direct detection
+        from .status_detector_factory import create_status_detector
+        detector = create_status_detector(
+            session,
+            strategy="hooks" if sess.hook_status_detection else "polling",
+        )
+        status, activity, pane_content_raw = detector.detect_status(sess)
 
     if sess.is_asleep:
         status = "asleep"
 
+    # Capture pane content separately if needed for display or stats parsing
+    need_pane = (not stats_only and lines > 0) or not no_stats
+    if need_pane and not pane_content_raw and sess.status != "terminated":
+        from .status_detector_factory import StatusDetectorDispatcher
+        dispatcher = StatusDetectorDispatcher(session)
+        pane_content_raw = dispatcher.get_pane_content(sess.tmux_window, num_lines=max(lines, 50))
+
     if not no_stats:
         # Gather all stats
         bg_bash_count = extract_background_bash_count(pane_content_raw) if pane_content_raw else 0
@@ -384,97 +464,40 @@ def show(
         except Exception:
             pass
 
-        uptime = calculate_uptime(sess.start_time) if sess.start_time else "-"
-        green_time, non_green_time, sleep_time = get_current_state_times(
-            sess.stats, is_asleep=sess.is_asleep
-        )
-        active_time = green_time + non_green_time
-        active_pct = (green_time / active_time * 100) if active_time > 0 else 0
-
+        # AI summaries from daemon state
         ai_short = ""
         ai_context = ""
-        try:
-            daemon_state = get_monitor_daemon_state(session)
-            if daemon_state:
-                ds = daemon_state.get_session_by_name(name)
-                if ds:
-                    ai_short = ds.activity_summary or ""
-                    ai_context = ds.activity_summary_context or ""
-        except Exception:
-            pass
+        if daemon_session:
+            ai_short = daemon_session.activity_summary or ""
+            ai_context = daemon_session.activity_summary_context or ""
+
+        # Build context and render via column system
+        any_has_budget = sess.cost_budget_usd > 0
+        ctx = build_cli_context(
+            session=sess,
+            stats=sess.stats,
+            claude_stats=claude_stats,
+            git_diff_stats=git_diff,
+            status=status,
+            bg_bash_count=bg_bash_count,
+            live_sub_count=live_sub_count,
+            any_has_budget=any_has_budget,
+        )
 
-        # Status line
-        symbol, _ = get_status_symbol(status)
-        time_in_state = ""
-        if sess.stats.state_since:
-            try:
-                from datetime import datetime
-                elapsed = (datetime.now() - datetime.fromisoformat(sess.stats.state_since)).total_seconds()
-                time_in_state = f" ({format_duration(elapsed)})"
-            except (ValueError, TypeError):
-                pass
-
-        # Permissiveness emoji
-        perm_map = {"bypass": "🔥 bypass", "permissive": "🏃 permissive", "normal": "👮 normal"}
-        perm_display = perm_map.get(sess.permissiveness_mode, sess.permissiveness_mode)
-
-        # Render stats
         print(f"=== {name} ===")
-        print(f"Status:    {symbol} {status}{time_in_state:<16} Uptime:  {uptime}")
-        repo_info = f"{sess.repo_name or '-'}:{sess.branch or '-'}"
-        tc_display = "🕐 enabled" if sess.time_context_enabled else "disabled"
-        print(f"Repo:      {repo_info:<28} Mode:    {perm_display}")
-        print(f"Time ctx:  {tc_display}")
-
-        # Time
-        time_str = f"▶ {format_duration(green_time):>5} active  ⏸ {format_duration(non_green_time):>5} stalled  💤 {format_duration(sleep_time):>5} sleep  ({active_pct:.0f}%)"
-        print(f"Time:      {time_str}")
-
-        # Tokens & cost
-        if claude_stats:
-            token_str = f"Σ {format_tokens(claude_stats.total_tokens)}"
-            if claude_stats.current_context_tokens > 0:
-                ctx_pct = min(100, claude_stats.current_context_tokens / 200_000 * 100)
-                token_str += f" (context {ctx_pct:.0f}%)"
-            cost = sess.stats.estimated_cost_usd
-            budget = sess.cost_budget_usd
-            if budget > 0:
-                cost_display = f"{format_cost(cost)}/{format_cost(budget)}"
-            else:
-                cost_display = format_cost(cost)
-            print(f"Tokens:    {token_str:<28} Cost:    {cost_display}")
-
-            # Work & interactions
-            median_work = claude_stats.median_work_time
-            work_str = format_duration(median_work) if median_work > 0 else "-"
-            human_count = max(0, claude_stats.interaction_count - sess.stats.steers_count)
-            print(f"Work:      ⏱ {work_str} median{'':<18} Interactions: 👤 {human_count} human 🤖 {sess.stats.steers_count} robot")
-        else:
-            print(f"Tokens:    -")
-
-        # Git
-        if git_diff:
-            files, ins, dels = git_diff
-            print(f"Git:       Δ{files} files +{format_line_count(ins)} -{format_line_count(dels)}")
-
-        # Subagents & background bashes (live counts from status bar)
-        print(f"Agents:    🤿 {live_sub_count} subagents  🐚 {bg_bash_count} background bashes")
-
-        # Standing orders
-        if sess.standing_instructions:
-            prefix = "✓ " if sess.standing_orders_complete else ""
-            instr = sess.standing_instructions[:80]
-            print(f"Orders:    📋 {prefix}{instr}")
+        label_width = max(len(label) for label, _ in render_cli_stats(ctx)) + 1
+        for label, value in render_cli_stats(ctx):
+            print(f"{label + ':':<{label_width + 1}} {value}")
 
-        # AI summaries
+        # AI summaries (not a column — comes from daemon state)
         if ai_short:
-            print(f"AI:        {ai_short}")
+            print(f"{'AI:':<{label_width + 1}} {ai_short}")
         if ai_context:
-            print(f"Context:   {ai_context}")
+            print(f"{'Context:':<{label_width + 1}} {ai_context}")
 
-        # Activity from status detector
+        # Activity from status detector (not a column — transient)
         if activity:
-            print(f"Activity:  {activity[:100]}")
+            print(f"{'Activity:':<{label_width + 1}} {activity[:100]}")
 
         print()
 
@@ -498,42 +521,25 @@ def show(
                 rprint(f"[dim]No pane output available[/dim]")
 
 
-@app.command("time-context")
-def time_context():
-    """Output a compact time-awareness line for Claude Code hooks.
-
-    Called by a UserPromptSubmit hook on every prompt. Outputs a single
-    line with clock, presence, office hours, uptime, and heartbeat info.
-    Silently exits when not in an overcode-managed session (env vars missing).
-    """
-    from .time_context import get_agent_identity, generate_time_context
-
-    name, tmux = get_agent_identity()
-    if not name or not tmux:
-        raise typer.Exit(0)
-
-    line = generate_time_context(tmux, name)
-    if not line:
-        raise typer.Exit(0)
-    print(line)
+# =============================================================================
+# Hooks Commands
+# =============================================================================
 
 
-@app.command("install-hook")
-def install_hook(
+@hooks_app.command("install")
+def hooks_install(
     project: Annotated[
         bool,
         typer.Option("--project", "-p", help="Install to project-level .claude/settings.json instead of user-level"),
     ] = False,
 ):
-    """Install the time-context hook into Claude Code settings.
+    """Install all overcode hooks into Claude Code settings.
 
-    By default installs to user-level settings (~/.claude/settings.json).
-    Use --project to install to the current project's .claude/settings.json.
-
-    The hook runs 'overcode time-context' on every prompt, giving Claude
-    continuous awareness of clock, presence, office hours, and uptime.
+    Installs hooks for: UserPromptSubmit, PostToolUse, Stop,
+    PermissionRequest, SessionEnd. All use the unified 'overcode hook-handler'.
     """
     from .claude_config import ClaudeConfigEditor
+    from .hook_handler import OVERCODE_HOOKS
 
     if project:
         editor = ClaudeConfigEditor.project_level()
@@ -543,18 +549,107 @@ def install_hook(
         level = "user"
 
     try:
-        added = editor.add_hook("UserPromptSubmit", "overcode time-context")
+        settings = editor.load()
     except ValueError as e:
         rprint(f"[red]Error:[/red] {e}")
         raise typer.Exit(1)
 
-    if added:
-        rprint(f"[green]\u2713[/green] Installed time-context hook in {level} settings")
+    # Install all overcode hooks (idempotent)
+    installed = 0
+    already = 0
+    for event, command in OVERCODE_HOOKS:
+        if editor.add_hook(event, command):
+            installed += 1
+        else:
+            already += 1
+
+    if installed > 0:
+        events = ", ".join(event for event, _ in OVERCODE_HOOKS)
+        rprint(f"[green]\u2713[/green] Installed {installed} hook(s) in {level} settings")
         rprint(f"  [dim]{editor.path}[/dim]")
-        rprint(f"\n  [dim]The hook runs 'overcode time-context' on every prompt.[/dim]")
-        rprint(f"  [dim]Toggle per-agent with F in the TUI.[/dim]")
+        rprint(f"\n  Events: {events}")
+        rprint(f"  All hooks run 'overcode hook-handler' (reads event from stdin).")
+    elif already == len(OVERCODE_HOOKS):
+        rprint(f"[green]\u2713[/green] All {already} hooks already installed in {level} settings")
+
+
+@hooks_app.command("uninstall")
+def hooks_uninstall(
+    project: Annotated[
+        bool,
+        typer.Option("--project", "-p", help="Uninstall from project-level .claude/settings.json instead of user-level"),
+    ] = False,
+):
+    """Remove all overcode hooks from Claude Code settings."""
+    from .claude_config import ClaudeConfigEditor
+    from .hook_handler import OVERCODE_HOOKS
+
+    if project:
+        editor = ClaudeConfigEditor.project_level()
+        level = "project"
     else:
-        rprint(f"[green]\u2713[/green] Hook already installed in {level} settings ({editor.path})")
+        editor = ClaudeConfigEditor.user_level()
+        level = "user"
+
+    try:
+        editor.load()
+    except ValueError as e:
+        rprint(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    removed = 0
+    for event, command in OVERCODE_HOOKS:
+        if editor.remove_hook(event, command):
+            removed += 1
+
+    if removed > 0:
+        rprint(f"[green]\u2713[/green] Removed {removed} hook(s) from {level} settings")
+    else:
+        rprint(f"[dim]No overcode hooks found in {level} settings[/dim]")
+
+
+@hooks_app.command("status")
+def hooks_status():
+    """Show which overcode hooks are installed."""
+    from .claude_config import ClaudeConfigEditor
+    from .hook_handler import OVERCODE_HOOKS
+
+    for level_name, editor in [
+        ("User-level", ClaudeConfigEditor.user_level()),
+        ("Project-level", ClaudeConfigEditor.project_level()),
+    ]:
+        try:
+            editor.load()
+        except ValueError:
+            rprint(f"\n{level_name} ({editor.path}):")
+            rprint(f"  [red](invalid JSON)[/red]")
+            continue
+
+        if not editor.path.exists():
+            rprint(f"\n{level_name} ({editor.path}):")
+            rprint(f"  [dim](no settings file)[/dim]")
+            continue
+
+        rprint(f"\n{level_name} ({editor.path}):")
+
+        for event, command in OVERCODE_HOOKS:
+            if editor.has_hook(event, command):
+                rprint(f"  {event:<20} {command}  [green]\u2713[/green]")
+            else:
+                rprint(f"  {event:<20} [dim]not installed[/dim]")
+
+
+@app.command("hook-handler", hidden=True)
+def hook_handler_cmd():
+    """Handle Claude Code hook events (internal).
+
+    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.
+    """
+    from .hook_handler import handle_hook_event
+
+    handle_hook_event()
 
 
 @app.command()
@@ -634,6 +729,12 @@ def instruct(
             rprint(f"[dim]Tip: Use 'overcode presets' to see available presets[/dim]")
 
 
+def _signal_heartbeat_change(session: str) -> None:
+    """Wake the monitor daemon so heartbeat status updates immediately (#212)."""
+    from .settings import signal_activity
+    signal_activity(session)
+
+
 @app.command()
 def heartbeat(
     name: Annotated[str, typer.Argument(help="Name of agent")],
@@ -726,6 +827,7 @@ def heartbeat(
             heartbeat_paused=False,
             heartbeat_instruction="",
         )
+        _signal_heartbeat_change(session)
         rprint(f"[green]✓ Heartbeat disabled for {name}[/green]")
         return
 
@@ -735,6 +837,7 @@ def heartbeat(
             rprint(f"[yellow]Heartbeat is not enabled for {name}[/yellow]")
             return
         manager.update_session(agent.id, heartbeat_paused=True)
+        _signal_heartbeat_change(session)
         rprint(f"[green]✓ Heartbeat paused for {name}[/green]")
         return
 
@@ -744,6 +847,7 @@ def heartbeat(
             rprint(f"[yellow]Heartbeat is not enabled for {name}[/yellow]")
             return
         manager.update_session(agent.id, heartbeat_paused=False)
+        _signal_heartbeat_change(session)
         rprint(f"[green]✓ Heartbeat resumed for {name}[/green]")
         return
 
@@ -761,6 +865,7 @@ def heartbeat(
             heartbeat_frequency_seconds=final_freq,
             heartbeat_instruction=instruction,
         )
+        _signal_heartbeat_change(session)
         rprint(f"[green]✓ Heartbeat enabled for {name}[/green]")
         rprint(f"  Frequency: {format_duration(final_freq)}")
         rprint(f"  Instruction: {instruction}")
@@ -775,6 +880,7 @@ def heartbeat(
 
     if updates:
         manager.update_session(agent.id, **updates)
+        _signal_heartbeat_change(session)
         rprint(f"[green]✓ Heartbeat config updated for {name}[/green]")
         if freq_seconds:
             rprint(f"  Frequency: {format_duration(freq_seconds)}")