overcode 0.3.1__tar.gz → 0.3.2__tar.gz

{overcode-0.3.1/src/overcode.egg-info → overcode-0.3.2}/PKG-INFO

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

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

{overcode-0.3.1 → overcode-0.3.2}/src/overcode/cli/split.py

@@ -34,6 +34,7 @@ from typing import Annotated
 import typer
 
 from ._shared import app, SessionOption
+from ..tmux_utils import get_pane_base_index
 
 
 def _acquire_setup_lock() -> bool:
@@ -179,11 +180,13 @@ def _setup_linked_session(agents_session: str) -> str:
 
 def _are_keybindings_installed() -> bool:
     """Check if overcode keybindings are already installed."""
-    # Check for our Tab binding as a sentinel
+    # Check for our M-j binding as a sentinel — look for the exact
+    # send-keys target rather than a substring match on the window name,
+    # to avoid false positives from unrelated bindings (#384).
     result = _tmux("list-keys", "-T", "root")
     if result.returncode != 0:
         return False
-    return SPLIT_WINDOW_NAME in result.stdout
+    return f"send-keys -t overcode:{SPLIT_WINDOW_NAME}." in result.stdout
 
 
 def _remove_keybindings() -> None:
@@ -232,27 +235,28 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
     # --- Agent navigation from the bottom (terminal) pane ---
     # Option+J / Option+K (Meta+j/k) cycle agents by sending j/k
     # to the monitor pane, which navigates and syncs the terminal.
+    _base = get_pane_base_index()
     _in_bottom = (
         f"#{{&&:#{{==:#{{window_name}},{SPLIT_WINDOW_NAME}}},"
-        f"#{{!=:#{{pane_index}},0}}}}"
+        f"#{{!=:#{{pane_index}},{_base}}}}}"
     )
     _tmux(
         "bind-key", "-n", "M-j",
         "if-shell", "-F", _in_bottom,
-        f"send-keys -t overcode:{SPLIT_WINDOW_NAME}.0 j",
+        f"send-keys -t overcode:{SPLIT_WINDOW_NAME}.{_base} j",
         "send-keys M-j",
     )
     _tmux(
         "bind-key", "-n", "M-k",
         "if-shell", "-F", _in_bottom,
-        f"send-keys -t overcode:{SPLIT_WINDOW_NAME}.0 k",
+        f"send-keys -t overcode:{SPLIT_WINDOW_NAME}.{_base} k",
         "send-keys M-k",
     )
     # Option+B: navigate to bell (next agent needing attention)
     _tmux(
         "bind-key", "-n", "M-b",
         "if-shell", "-F", _in_bottom,
-        f"send-keys -t overcode:{SPLIT_WINDOW_NAME}.0 b",
+        f"send-keys -t overcode:{SPLIT_WINDOW_NAME}.{_base} b",
         "send-keys M-b",
     )
 
@@ -263,12 +267,12 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
     # copy mode in the inner session via the tmux API.
     if linked_session:
         # PageUp: enter copy mode + scroll up, but only when in the
-        # bottom pane (pane_index != 0) of the split window.
+        # bottom pane (pane_index != base) of the split window.
         # Top pane (Textual TUI) and other windows get normal PageUp.
         _tmux(
             "bind-key", "-n", "PPage",
             "if-shell", "-F",
-            f"#{{&&:#{{==:#{{window_name}},{SPLIT_WINDOW_NAME}}},#{{!=:#{{pane_index}},0}}}}",
+            f"#{{&&:#{{==:#{{window_name}},{SPLIT_WINDOW_NAME}}},#{{!=:#{{pane_index}},{_base}}}}}",
             f"copy-mode -t {linked_session} -u",
             "send-keys PPage",
         )
@@ -276,7 +280,7 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
         _tmux(
             "bind-key", "-n", "NPage",
             "if-shell", "-F",
-            f"#{{&&:#{{==:#{{window_name}},{SPLIT_WINDOW_NAME}}},#{{!=:#{{pane_index}},0}}}}",
+            f"#{{&&:#{{==:#{{window_name}},{SPLIT_WINDOW_NAME}}},#{{!=:#{{pane_index}},{_base}}}}}",
             f"send-keys -t {linked_session} NPage",
             "send-keys NPage",
         )
@@ -288,7 +292,7 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
         # already active), then send scroll-up/down commands to it.
         _in_bottom = (
             f"#{{&&:#{{==:#{{window_name}},{SPLIT_WINDOW_NAME}}},"
-            f"#{{!=:#{{pane_index}},0}}}}"
+            f"#{{!=:#{{pane_index}},{_base}}}}}"
         )
         _tmux(
             "bind-key", "-n", "WheelUpPane",
@@ -410,7 +414,7 @@ def tmux_resize():
 
     # Apply the new ratio
     new_height = max(int(int(info.split(":")[1]) * next_ratio / 100), 5)
-    _tmux("resize-pane", "-t", f"{target}.0", "-y", str(new_height))
+    _tmux("resize-pane", "-t", f"{target}.{get_pane_base_index()}", "-y", str(new_height))
 
 
 @app.command("tmux")
@@ -601,20 +605,30 @@ def _tmux_layout_locked(session: str, ratio: int, rprint) -> None:
     if existing:
         if _is_split_window_healthy(existing):
             if in_tmux:
-                # Check if a real (non-tiny) client is already on overcode.
+                # Check if a real (non-nested) client is already on overcode.
                 # If so, no switch needed — the user is already there or
                 # another terminal has it open.  Switching blindly can
                 # accidentally move the bottom pane's nested client from
                 # oc-view-agents to overcode, creating a recursive display
                 # that collapses the window.
+                #
+                # Detect nested clients by comparing client TTYs against
+                # pane TTYs in the split window (#387). A nested tmux
+                # client's TTY matches one of the pane TTYs.
+                pane_ttys = set(
+                    _tmux_output(
+                        "list-panes", "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}",
+                        "-F", "#{pane_tty}",
+                    ).splitlines()
+                )
                 oc_clients = _tmux_output(
                     "list-clients", "-t", oc_session,
-                    "-F", "#{client_height}",
+                    "-F", "#{client_tty}",
                 )
                 has_real_client = any(
-                    int(h) > 10
-                    for h in oc_clients.splitlines()
-                    if h.strip().isdigit()
+                    tty.strip() not in pane_ttys
+                    for tty in oc_clients.splitlines()
+                    if tty.strip()
                 )
                 if not has_real_client:
                     # No real client on overcode yet — switch the caller's
@@ -632,14 +646,14 @@ def _tmux_layout_locked(session: str, ratio: int, rprint) -> None:
             else:
                 # Respawn before attach — execlp replaces this process
                 _tmux("respawn-pane", "-k",
-                      "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}.0",
+                      "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}.{get_pane_base_index()}",
                       monitor_cmd)
                 rprint(f"[green]Attaching to existing {SPLIT_WINDOW_NAME} window (monitor restarted)...[/green]")
                 time.sleep(0.2)
                 os.execlp("tmux", "tmux", "attach-session", "-t", oc_session)
             # Always restart the monitor so code changes take effect
             _tmux("respawn-pane", "-k",
-                  "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}.0",
+                  "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}.{get_pane_base_index()}",
                   monitor_cmd)
             rprint(f"[green]Switched to existing {SPLIT_WINDOW_NAME} window (monitor restarted)[/green]")
             return
@@ -668,7 +682,7 @@ def _tmux_layout_locked(session: str, ratio: int, rprint) -> None:
 
     # The bottom pane runs a nested tmux attach. We must unset $TMUX
     # because tmux refuses to attach from inside an existing session.
-    attach_cmd = f"unset TMUX; tmux attach-session -t {linked}"
+    attach_cmd = f"sh -c 'unset TMUX; exec tmux attach-session -t {linked}'"
 
     # If an "overcode" session exists but has no split window, it might be:
     # (a) a stale session from a previous overcode run, or
@@ -749,7 +763,7 @@ def _tmux_layout_locked(session: str, ratio: int, rprint) -> None:
         result = _tmux(
             "split-window", "-v",
             "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}",
-            "-p", str(100 - ratio),
+            "-l", f"{100 - ratio}%",
             attach_cmd,
         )
         if result.returncode != 0:
@@ -757,17 +771,23 @@ def _tmux_layout_locked(session: str, ratio: int, rprint) -> None:
             raise typer.Exit(1)
 
         # Focus top pane
-        _tmux("select-pane", "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}.0")
+        _tmux("select-pane", "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}.{get_pane_base_index()}")
 
         rprint(f"[green]Split layout ready.[/green] Tab toggles panes.")
 
     else:
         # --- Outside tmux: create detached, split, then attach ---
         if need_new_session:
+            # Use actual terminal size (fall back to 200x50 if unavailable)
+            try:
+                term_size = os.get_terminal_size()
+                term_x, term_y = str(term_size.columns), str(term_size.lines)
+            except OSError:
+                term_x, term_y = "200", "50"
             result = _tmux(
                 "new-session", "-d", "-s", oc_session,
                 "-n", SPLIT_WINDOW_NAME,
-                "-x", "200", "-y", "50",
+                "-x", term_x, "-y", term_y,
                 monitor_cmd,
             )
             if result.returncode != 0:
@@ -792,12 +812,12 @@ def _tmux_layout_locked(session: str, ratio: int, rprint) -> None:
         _tmux(
             "split-window", "-v",
             "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}",
-            "-p", str(100 - ratio),
+            "-l", f"{100 - ratio}%",
             attach_cmd,
         )
 
         # Focus top pane
-        _tmux("select-pane", "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}.0")
+        _tmux("select-pane", "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}.{get_pane_base_index()}")
 
         # Attach to the session (replaces this process)
         rprint(f"[green]Attaching to split layout...[/green]")

{overcode-0.3.1 → overcode-0.3.2}/src/overcode/job_launcher.py

@@ -111,23 +111,38 @@ class JobLauncher:
         if not detect_killed:
             return jobs
 
-        # Get list of actual tmux windows
+        # Get list of actual tmux windows.
+        # If the list is empty, it's likely a query failure (stale libtmux
+        # session cache or transient error) rather than all windows being
+        # gone — skip kill detection entirely to avoid false kills (#396).
         windows = self.tmux.list_windows()
+        if not windows:
+            return jobs
         window_names = {w['name'] for w in windows}
 
+        now = datetime.now()
         for job in jobs:
             if job.status != "running":
                 continue
 
             if job.tmux_window not in window_names:
+                # Grace period: don't mark as killed until the job has been
+                # "missing" for at least 30s, to avoid race conditions during
+                # window creation (#396).
+                try:
+                    age = (now - datetime.fromisoformat(job.start_time)).total_seconds()
+                except (ValueError, TypeError):
+                    age = 0
+                if age < 30:
+                    continue
                 # Window gone but no _complete called → killed
                 self.jobs.update_job(
                     job.id,
                     status="killed",
-                    end_time=datetime.now().isoformat(),
+                    end_time=now.isoformat(),
                 )
                 job.status = "killed"
-                job.end_time = datetime.now().isoformat()
+                job.end_time = now.isoformat()
                 continue
 
             # Window still alive — check if the command has finished by

{overcode-0.3.1 → overcode-0.3.2}/src/overcode/settings.py

@@ -508,7 +508,7 @@ class TUIPreferences:
     # Only stores explicit user overrides. Missing = use default from detail_levels.
     column_config: dict = field(default_factory=dict)
     # Show abbreviated column headers above summary lines
-    show_column_headers: bool = False
+    show_column_headers: bool = True
     # Sister instances hidden from agent list (#323)
     disabled_sisters: Set[str] = field(default_factory=set)
     # Log every status change to diagnostics CSV (off by default)

{overcode-0.3.1 → overcode-0.3.2}/src/overcode/status_detector.py

@@ -170,11 +170,18 @@ class PollingStatusDetector:
         # But if a user prompt is visible, the agent is waiting — content
         # changes from TUI refreshes or status-bar updates shouldn't override
         # prompt detection.
+        #
+        # HOWEVER: Claude Code always renders the ❯ prompt as UI chrome, even
+        # while actively working (#393). When active indicators like
+        # "esc to interrupt" are present, the prompt is just decoration —
+        # trust the active indicators over the prompt char.
         if content_changed:
-            prompt_result = self._detect_user_prompt(last_lines, content)
-            if prompt_result is not None:
-                self._last_detect_phase[session.id] = "P5+P12:prompt_override"
-                return prompt_result
+            has_active_indicator = matches_any(last_few, self.patterns.active_indicators)
+            if not has_active_indicator:
+                prompt_result = self._detect_user_prompt(last_lines, content)
+                if prompt_result is not None:
+                    self._last_detect_phase[session.id] = "P5+P12:prompt_override"
+                    return prompt_result
             activity = self._extract_last_activity(last_lines)
             self._last_detect_phase[session.id] = "P5:content_changed"
             return STATUS_RUNNING, f"Active: {activity}", content

{overcode-0.3.1 → overcode-0.3.2}/src/overcode/supervisor_layout.sh

@@ -33,18 +33,23 @@ fi
 # Create new session with the TUI
 tmux new-session -d -s "$CONTROLLER_SESSION" -n "controller"
 
+# Query pane-base-index (default 0, commonly set to 1)
+PANE_BASE=$(tmux show-options -gv pane-base-index 2>/dev/null || echo 0)
+PANE_BASE=${PANE_BASE:-0}
+PANE_BOTTOM=$((PANE_BASE + 1))
+
 # Split window horizontally (top 33%, bottom 66%)
-tmux split-window -v -p 66 -t "$CONTROLLER_SESSION:0"
+tmux split-window -v -l 66% -t "$CONTROLLER_SESSION:0"
 
 # Top pane: Run the TUI (without piping to preserve terminal control)
-tmux send-keys -t "$CONTROLLER_SESSION:0.0" "PYTHONUNBUFFERED=1 python -m overcode.tui $SESSION_NAME" C-m
+tmux send-keys -t "$CONTROLLER_SESSION:0.$PANE_BASE" "PYTHONUNBUFFERED=1 python -m overcode.tui $SESSION_NAME" C-m
 
 # Bottom pane: Launch Claude (no auto-prompt - let user interact naturally)
-tmux send-keys -t "$CONTROLLER_SESSION:0.1" "claude" C-m
+tmux send-keys -t "$CONTROLLER_SESSION:0.$PANE_BOTTOM" "claude" C-m
 
 # Set pane titles
-tmux select-pane -t "$CONTROLLER_SESSION:0.0" -T "Overcode Monitor"
-tmux select-pane -t "$CONTROLLER_SESSION:0.1" -T "Controller"
+tmux select-pane -t "$CONTROLLER_SESSION:0.$PANE_BASE" -T "Overcode Monitor"
+tmux select-pane -t "$CONTROLLER_SESSION:0.$PANE_BOTTOM" -T "Controller"
 
 # Attach to the session
 exec tmux attach-session -t "$CONTROLLER_SESSION"

{overcode-0.3.1 → overcode-0.3.2}/src/overcode/tmux_manager.py

@@ -53,6 +53,7 @@ class TmuxManager:
         except (LibTmuxException, ObjectDoesNotExist):
             return None
 
+
     def _get_window(self, window_name: str) -> Optional[libtmux.Window]:
         """Get a window by name.
 

{overcode-0.3.1 → overcode-0.3.2}/src/overcode/tmux_utils.py

@@ -109,6 +109,28 @@ def attach_bare(session_name: str, window_name: str, socket_path: str = None) ->
     os.execlp(tmux_cmd[0], *tmux_cmd, "attach-session", "-t", bare_session)
 
 
+_pane_base_index: Optional[int] = None
+
+
+def get_pane_base_index() -> int:
+    """Return the tmux pane-base-index setting (default 0, commonly set to 1).
+
+    The result is cached for the lifetime of the process.
+    """
+    global _pane_base_index
+    if _pane_base_index is not None:
+        return _pane_base_index
+    try:
+        result = subprocess.run(
+            _build_tmux_cmd() + ["show-options", "-gv", "pane-base-index"],
+            capture_output=True, text=True, timeout=5,
+        )
+        _pane_base_index = int(result.stdout.strip()) if result.returncode == 0 and result.stdout.strip() else 0
+    except (subprocess.TimeoutExpired, ValueError, OSError):
+        _pane_base_index = 0
+    return _pane_base_index
+
+
 def tmux_window_target(session: str, window) -> str:
     """Build tmux target string for a window.
 

{overcode-0.3.1 → overcode-0.3.2}/src/overcode/tui.py

@@ -44,6 +44,7 @@ from .summarizer_component import (
 from .sister_poller import SisterPoller
 from .usage_monitor import UsageMonitor
 from .implementations import RealTmux
+from .tmux_utils import get_pane_base_index
 from .tui_helpers import (
     format_duration,
     get_git_diff_stats,
@@ -128,8 +129,8 @@ class SupervisorTUI(
         ("backslash", "monitor_restart", "Restart monitor"),
         ("a", "focus_human_annotation", "Annotation"),
         ("A", "toggle_summarizer", "AI summarizer"),
-        # Manual refresh (useful in diagnostics mode)
-        ("r", "resize_focused_window", "Resize window"),
+        # Resize focused agent's tmux window to match pane size
+        ("r", "resize_focused_window", "Resize pane"),
         # Agent management
         ("x", "kill_focused", "Kill/Clean up"),
         ("R", "restart_focused", "Restart agent"),
@@ -868,6 +869,16 @@ class SupervisorTUI(
             pass
         return False
 
+    def _tui_pane_target(self) -> str:
+        """Return tmux target for the TUI (top) pane, respecting pane-base-index."""
+        base = get_pane_base_index()
+        return f"overcode:overcode-tmux.{base}"
+
+    def _bottom_pane_target(self) -> str:
+        """Return tmux target for the bottom (terminal) pane, respecting pane-base-index."""
+        base = get_pane_base_index()
+        return f"overcode:overcode-tmux.{base + 1}"
+
     def _dialog_will_open(self) -> None:
         """Zoom the tmux monitor pane when a dialog opens (compact mode only).
 
@@ -877,7 +888,7 @@ class SupervisorTUI(
         if not self.compact:
             return
         import subprocess
-        target = "overcode:overcode-tmux.0"
+        target = self._tui_pane_target()
         # Don't zoom if already zoomed
         info = subprocess.run(
             ["tmux", "display-message", "-t", target, "-p", "#{window_zoomed_flag}"],
@@ -903,7 +914,7 @@ class SupervisorTUI(
         if self.tui_mode == "jobs":
             return
         import subprocess
-        target = "overcode:overcode-tmux.0"
+        target = self._tui_pane_target()
         info = subprocess.run(
             ["tmux", "display-message", "-t", target, "-p", "#{window_zoomed_flag}"],
             capture_output=True, text=True,
@@ -943,7 +954,7 @@ class SupervisorTUI(
         # Unzoom — but only if no dialog is holding the zoom open
         if not self._any_dialog_visible():
             import subprocess
-            target = "overcode:overcode-tmux.0"
+            target = self._tui_pane_target()
             info = subprocess.run(
                 ["tmux", "display-message", "-t", target, "-p", "#{window_zoomed_flag}"],
                 capture_output=True, text=True,
@@ -3170,7 +3181,7 @@ class SupervisorTUI(
             return
         import subprocess
         subprocess.run(
-            ["tmux", "resize-pane", "-t", "overcode:overcode-tmux.0",
+            ["tmux", "resize-pane", "-t", self._tui_pane_target(),
              "-U" if delta > 0 else "-D", str(abs(delta))],
             capture_output=True,
         )

{overcode-0.3.1 → overcode-0.3.2}/src/overcode/tui_actions/session.py

@@ -512,6 +512,10 @@ class SessionActionsMixin:
                 session.id,
                 current_task="Synced to main"
             )
+            # Clear PR number — agent is back on main, old PR is stale (#391)
+            self.session_manager.update_session(
+                session.id, pr_number=None, pr_branch=None
+            )
         else:
             self.notify(f"Failed to send /clear to '{session_name}'", severity="error")
 

{overcode-0.3.1 → overcode-0.3.2}/src/overcode/tui_actions/view.py

@@ -84,7 +84,7 @@ class ViewActionsMixin:
 
             # Get the bottom pane's actual dimensions (pane 1 in the split)
             result = subprocess.run(
-                ["tmux", "display-message", "-t", "overcode:overcode-tmux.1",
+                ["tmux", "display-message", "-t", self._bottom_pane_target(),
                  "-p", "#{pane_width} #{pane_height}"],
                 capture_output=True, text=True,
             )

{overcode-0.3.1 → overcode-0.3.2}/src/overcode/tui_widgets/help_overlay.py

@@ -39,7 +39,7 @@ class HelpOverlay(Static):
 
         section("VIEW")
         row("m", "Toggle preview pane", "f", "Fullscreen preview")
-        row("r", "Refresh")
+        row("r", "Resize pane")
         t.append("\n")
 
         section("DISPLAY")

{overcode-0.3.1 → overcode-0.3.2/src/overcode.egg-info}/PKG-INFO

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