overcode 0.2.5__tar.gz → 0.2.6__tar.gz

{overcode-0.2.5/src/overcode.egg-info → overcode-0.2.6}/PKG-INFO

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

{overcode-0.2.5 → overcode-0.2.6}/pyproject.toml

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

{overcode-0.2.5 → overcode-0.2.6}/src/overcode/cli/agent.py

@@ -212,6 +212,68 @@ def launch(
         rprint("\nTo view: [bold]overcode attach[/bold]")
 
 
+@app.command()
+def fork(
+    source: Annotated[str, typer.Argument(help="Name of agent to fork from")],
+    name: Annotated[
+        Optional[str], typer.Option("--name", "-n", help="Name for the forked agent (default: <source>-fork)")
+    ] = None,
+    prompt: Annotated[
+        Optional[str], typer.Option("--prompt", "-p", help="Initial prompt to send to the fork")
+    ] = None,
+    session: SessionOption = "agents",
+):
+    """Fork an agent, creating a child with the source's conversation context.
+
+    Uses Claude's --resume --fork-session to branch the conversation history
+    into a new independent agent. The forked agent inherits the source's
+    directory, permissions, agent persona, and CLI flags.
+
+    Examples:
+        overcode fork my-agent                          # Fork as my-agent-fork
+        overcode fork my-agent -n side-analysis         # Fork with custom name
+        overcode fork my-agent -p "analyze test failures"  # Fork with initial prompt
+    """
+    from ..session_manager import SessionManager
+
+    sm = SessionManager()
+    source_session = sm.get_session_by_name(source)
+    if not source_session:
+        rprint(f"[red]Error: Agent '{source}' not found[/red]")
+        raise typer.Exit(code=1)
+
+    if not source_session.active_claude_session_id:
+        rprint(f"[red]Error: Agent '{source}' has no active Claude session ID yet[/red]")
+        rprint("[dim]The monitor daemon detects session IDs periodically — try again shortly[/dim]")
+        raise typer.Exit(code=1)
+
+    if source_session.status in ("terminated", "done"):
+        rprint(f"[red]Error: Cannot fork a {source_session.status} agent[/red]")
+        raise typer.Exit(code=1)
+
+    # Default fork name
+    fork_name = name if name else f"{source}-fork"
+
+    launcher = ClaudeLauncher(session)
+    result = launcher.launch_fork(
+        name=fork_name,
+        source_session=source_session,
+        initial_prompt=prompt,
+    )
+
+    if result:
+        rprint(f"\n[green]✓[/green] Forked '[bold]{source}[/bold]' → '[bold]{fork_name}[/bold]'")
+        rprint(f"  Directory: {result.start_directory}")
+        if result.claude_agent:
+            rprint(f"  Agent: {result.claude_agent}")
+        if prompt:
+            rprint("  Initial prompt sent")
+        rprint(f"\nTo view: [bold]overcode attach {fork_name}[/bold]")
+    else:
+        rprint(f"[red]Error: Failed to fork '{source}'[/red]")
+        raise typer.Exit(code=1)
+
+
 @app.command("list")
 def list_agents(
     name: Annotated[
@@ -788,6 +850,9 @@ def show(
     stats_only: Annotated[
         bool, typer.Option("--stats-only", "-s", help="Show only stats, no pane output")
     ] = False,
+    color: Annotated[
+        bool, typer.Option("--color", "-c", help="Preserve ANSI colors in pane output")
+    ] = False,
     session: SessionOption = "agents",
 ):
     """Show agent details and recent output."""
@@ -908,12 +973,23 @@ def show(
     # Pane output section (skip if --stats-only or --lines 0)
     if not stats_only and lines > 0:
         if pane_content_raw:
-            clean_content = strip_ansi(pane_content_raw)
-            content_lines = clean_content.rstrip().split('\n')
-            display_lines = content_lines[-lines:]
-            print(f"=== {name} (last {lines} lines) ===")
-            print('\n'.join(display_lines))
-            print(f"=== end {name} ===")
+            if color:
+                from rich.console import Console
+                from rich.text import Text
+                console = Console()
+                raw_lines = pane_content_raw.rstrip().split('\n')
+                display_lines = raw_lines[-lines:]
+                console.print(f"=== {name} (last {lines} lines) ===")
+                for line in display_lines:
+                    console.print(Text.from_ansi(line))
+                console.print(f"=== end {name} ===")
+            else:
+                clean_content = strip_ansi(pane_content_raw)
+                content_lines = clean_content.rstrip().split('\n')
+                display_lines = content_lines[-lines:]
+                print(f"=== {name} (last {lines} lines) ===")
+                print('\n'.join(display_lines))
+                print(f"=== end {name} ===")
         else:
             # Fallback for terminated sessions
             output = launcher.get_session_output(name, lines=lines)

{overcode-0.2.5 → overcode-0.2.6}/src/overcode/daemon_utils.py

@@ -78,12 +78,29 @@ def create_daemon_helpers(
             os.kill(pid, signal.SIGTERM)
             # Wait for process to actually terminate before removing PID file
             start = time.time()
+            terminated = False
             while time.time() - start < 5.0:
                 try:
                     os.kill(pid, 0)
                     time.sleep(0.1)
                 except (OSError, ProcessLookupError):
+                    terminated = True
                     break
+
+            if not terminated:
+                # Still alive after timeout — force kill
+                try:
+                    os.kill(pid, signal.SIGKILL)
+                    time.sleep(0.1)
+                except (OSError, ProcessLookupError):
+                    pass
+
+            # Reap zombie if we're the parent process
+            try:
+                os.waitpid(pid, os.WNOHANG)
+            except ChildProcessError:
+                pass  # Not our child, or already reaped
+
             remove_pid_file(pid_path)
             return True
         except (OSError, ProcessLookupError):

{overcode-0.2.5 → overcode-0.2.6}/src/overcode/follow_mode.py

@@ -19,15 +19,16 @@ from .session_manager import SessionManager
 from .status_patterns import strip_ansi
 from .settings import get_session_dir
 from .status_constants import DEFAULT_CAPTURE_LINES, STATUS_WAITING_OVERSIGHT
+from .tmux_utils import tmux_window_target
 
 
-def _capture_pane(tmux_session: str, window_index: int, lines: int = DEFAULT_CAPTURE_LINES) -> Optional[str]:
+def _capture_pane(tmux_session: str, window_name: str, lines: int = DEFAULT_CAPTURE_LINES) -> Optional[str]:
     """Capture recent pane output via tmux."""
     try:
         result = subprocess.run(
             [
                 "tmux", "capture-pane",
-                "-t", f"{tmux_session}:{window_index}",
+                "-t", tmux_window_target(tmux_session, window_name),
                 "-p",
                 "-S", f"-{lines}",
             ],
@@ -143,7 +144,7 @@ def follow_agent(
         print(f"Error: Agent '{name}' not found", file=sys.stderr)
         return 1
 
-    window_index = session.tmux_window
+    window_name = session.tmux_window
 
     # Read oversight policy from session
     oversight_policy = getattr(session, 'oversight_policy', 'wait') or 'wait'
@@ -162,7 +163,7 @@ def follow_agent(
     try:
         while not interrupted:
             # Capture pane content
-            raw = _capture_pane(tmux_session, window_index)
+            raw = _capture_pane(tmux_session, window_name)
             if raw is None:
                 if _check_session_terminated(sessions, name):
                     print(f"\n[follow] Agent '{name}' terminated", file=sys.stderr)
@@ -176,7 +177,7 @@ def follow_agent(
             if _check_hook_stop(tmux_session, name):
                 # Wait one extra cycle to capture final output
                 time.sleep(poll_interval)
-                raw = _capture_pane(tmux_session, window_index)
+                raw = _capture_pane(tmux_session, window_name)
                 if raw:
                     for line in raw.rstrip().split('\n'):
                         cleaned = strip_ansi(line).strip()
@@ -226,7 +227,7 @@ def follow_agent(
 
                 # Enter report-polling sub-loop
                 return _poll_for_report(
-                    name, tmux_session, sessions, window_index,
+                    name, tmux_session, sessions, window_name,
                     oversight_policy, oversight_timeout_seconds,
                     poll_interval, recent_lines,
                 )
@@ -253,7 +254,7 @@ def _poll_for_report(
     name: str,
     tmux_session: str,
     sessions: SessionManager,
-    window_index: int,
+    window_name: str,
     oversight_policy: str,
     oversight_timeout_seconds: float,
     poll_interval: float,
@@ -307,7 +308,7 @@ def _poll_for_report(
             return 1
 
         # Continue streaming pane output while waiting
-        raw = _capture_pane(tmux_session, window_index)
+        raw = _capture_pane(tmux_session, window_name)
         if raw:
             _emit_new_lines(raw, recent_lines)
 

{overcode-0.2.5 → overcode-0.2.6}/src/overcode/hook_status_detector.py

@@ -140,13 +140,13 @@ class HookStatusDetector:
 
         return data
 
-    def get_pane_content(self, window: int, num_lines: int = 0) -> Optional[str]:
+    def get_pane_content(self, window: str, num_lines: int = 0) -> Optional[str]:
         """Get pane content via the polling detector's tmux interface."""
         fallback = self._get_polling_fallback()
         fallback.capture_lines = self.capture_lines
         return fallback.get_pane_content(window, num_lines)
 
-    def detect_status(self, session: "Session") -> Tuple[str, str, str]:
+    def detect_status(self, session: "Session", num_lines: int = 0) -> Tuple[str, str, str]:
         """Detect session status using hook state files.
 
         When fresh hook state exists, uses that for status determination.
@@ -160,7 +160,7 @@ class HookStatusDetector:
 
         if hook_state is None:
             # No hook state or stale → full polling fallback
-            return self._get_polling_fallback().detect_status(session)
+            return self._get_polling_fallback().detect_status(session, num_lines=num_lines)
 
         # Hook state is fresh → use it for status
         event = hook_state.get("event", "")
@@ -183,7 +183,7 @@ class HookStatusDetector:
             status = STATUS_WAITING_OVERSIGHT
 
         # Read pane for activity enrichment and content return value
-        pane_content = self.get_pane_content(session.tmux_window) or ""
+        pane_content = self.get_pane_content(session.tmux_window, num_lines=num_lines) or ""
 
         # Check for busy-sleeping: agent is "running" but executing a sleep command (#289)
         if status == STATUS_RUNNING:

{overcode-0.2.5 → overcode-0.2.6}/src/overcode/implementations.py

@@ -65,17 +65,27 @@ class RealTmux:
         except (LibTmuxException, ObjectDoesNotExist):
             return None
 
-    def _get_window(self, session: str, window: int) -> Optional[libtmux.Window]:
-        """Get a window by session name and window index."""
+    def _get_window(self, session: str, window: str) -> Optional[libtmux.Window]:
+        """Get a window by session name and window name.
+
+        Falls back to index-based lookup for legacy sessions that still have
+        digit-string window values (e.g. "4" from pre-name-based era).
+        """
         sess = self._get_session(session)
         if sess is None:
             return None
         try:
-            return sess.windows.get(window_index=str(window))
+            return sess.windows.get(window_name=window)
         except (LibTmuxException, ObjectDoesNotExist):
+            # Fallback: if window looks like a legacy index, try index lookup
+            if window.isdigit():
+                try:
+                    return sess.windows.get(window_index=window)
+                except (LibTmuxException, ObjectDoesNotExist):
+                    pass
             return None
 
-    def _get_pane(self, session: str, window: int) -> Optional[libtmux.Pane]:
+    def _get_pane(self, session: str, window: str) -> Optional[libtmux.Pane]:
         """Get the first pane of a window, with caching."""
         cache_key = (session, window)
         now = time.time()
@@ -94,7 +104,7 @@ class RealTmux:
         self._pane_cache[cache_key] = (pane, now)
         return pane
 
-    def invalidate_cache(self, session: str = None, window: int = None) -> None:
+    def invalidate_cache(self, session: str = None, window: str = None) -> None:
         """Invalidate cached objects.
 
         Args:
@@ -113,7 +123,7 @@ class RealTmux:
             for k in keys_to_remove:
                 del self._pane_cache[k]
 
-    def capture_pane(self, session: str, window: int, lines: int = 100) -> Optional[str]:
+    def capture_pane(self, session: str, window: str, lines: int = 100) -> Optional[str]:
         try:
             pane = self._get_pane(session, window)
             if pane is None:
@@ -129,7 +139,7 @@ class RealTmux:
             self.invalidate_cache(session, window)
             return None
 
-    def send_keys(self, session: str, window: int, keys: str, enter: bool = True) -> bool:
+    def send_keys(self, session: str, window: str, keys: str, enter: bool = True) -> bool:
         try:
             pane = self._get_pane(session, window)
             if pane is None:
@@ -188,7 +198,7 @@ class RealTmux:
             return False
 
     def new_window(self, session: str, name: str, command: Optional[List[str]] = None,
-                   cwd: Optional[str] = None) -> Optional[int]:
+                   cwd: Optional[str] = None) -> Optional[str]:
         try:
             sess = self._get_session(session)
             if sess is None:
@@ -201,11 +211,14 @@ class RealTmux:
                 kwargs['window_shell'] = ' '.join(command)
 
             window = sess.new_window(**kwargs)
-            return int(window.window_index)
+            # Prevent tmux from auto-renaming the window based on the
+            # running process — we rely on stable window names for lookups.
+            window.set_window_option('automatic-rename', 'off')
+            return window.window_name
         except (LibTmuxException, ValueError):
             return None
 
-    def kill_window(self, session: str, window: int) -> bool:
+    def kill_window(self, session: str, window: str) -> bool:
         try:
             win = self._get_window(session, window)
             if win is None:
@@ -242,16 +255,18 @@ class RealTmux:
         except LibTmuxException:
             return []
 
-    def attach(self, session: str, window: Optional[int] = None, bare: bool = False) -> None:
+    def attach(self, session: str, window: Optional[str] = None, bare: bool = False) -> None:
         if bare:
             self._attach_bare(session, window)
         else:
-            target = f"{session}:={window}" if window is not None else session
+            from .tmux_utils import tmux_window_target
+            target = tmux_window_target(session, window) if window is not None else session
             os.execlp("tmux", "tmux", "attach-session", "-t", target)
 
-    def _attach_bare(self, session: str, window: int) -> None:
+    def _attach_bare(self, session: str, window: str) -> None:
         """Create a linked session with stripped chrome and attach to it."""
         import subprocess
+        from .tmux_utils import tmux_window_target
 
         bare_session = f"bare-{session}-{window}"
 
@@ -271,13 +286,13 @@ class RealTmux:
             ["tmux", "set", "-t", bare_session, "status", "off"],
             ["tmux", "set", "-t", bare_session, "mouse", "off"],
             ["tmux", "set", "-t", bare_session, "destroy-unattached", "on"],
-            ["tmux", "select-window", "-t", f"{bare_session}:={window}"],
+            ["tmux", "select-window", "-t", tmux_window_target(bare_session, window)],
         ]:
             subprocess.run(cmd, capture_output=True)
 
         os.execlp("tmux", "tmux", "attach-session", "-t", bare_session)
 
-    def select_window(self, session: str, window: int) -> bool:
+    def select_window(self, session: str, window: str) -> bool:
         """Select a window in a tmux session (for external pane sync)."""
         try:
             win = self._get_window(session, window)