overcode 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

overcode/cli/__init__.py

@@ -25,6 +25,9 @@ from . import split  # noqa: F401
 from . import jobs  # noqa: F401
 from . import wrappers  # noqa: F401
 from . import doctor  # noqa: F401
+from . import parallelism  # noqa: F401
+from . import tags  # noqa: F401
+from . import focal  # noqa: F401
 
 
 def main():

overcode/cli/agent.py

@@ -64,11 +64,20 @@ def _check_skill_staleness() -> None:
 def _gather_session_stats(sess, pane_content_raw: str) -> dict:
     """Gather claude_stats, git_diff, bg_bash_count, live_sub_count for a session."""
     from ..history_reader import get_session_stats
-    from ..status_patterns import extract_background_bash_count, extract_live_subagent_count
-    from ..tui_helpers import get_git_diff_stats
+    from ..status_patterns import (
+        extract_background_bash_count,
+        extract_live_subagent_count,
+        extract_auto_accept_mode,
+    )
+    from ..tui_helpers import (
+        get_git_diff_stats,
+        get_git_untracked_count,
+        effective_git_directory,
+    )
 
     bg_bash_count = extract_background_bash_count(pane_content_raw) if pane_content_raw else 0
     live_sub_count = extract_live_subagent_count(pane_content_raw) if pane_content_raw else 0
+    auto_accept = extract_auto_accept_mode(pane_content_raw) if pane_content_raw else False
 
     claude_stats = None
     try:
@@ -79,17 +88,22 @@ def _gather_session_stats(sess, pane_content_raw: str) -> dict:
         pass
 
     git_diff = None
+    git_untracked = None
     try:
-        if sess.start_directory:
-            git_diff = get_git_diff_stats(sess.start_directory)
+        _gdir = effective_git_directory(sess)
+        if _gdir:
+            git_diff = get_git_diff_stats(_gdir)
+            git_untracked = get_git_untracked_count(_gdir)
     except Exception:
         pass
 
     return {
         "claude_stats": claude_stats,
         "git_diff": git_diff,
+        "git_untracked": git_untracked,
         "bg_bash_count": bg_bash_count,
         "live_sub_count": live_sub_count,
+        "auto_accept": auto_accept,
     }
 
 
@@ -220,6 +234,13 @@ def launch(
         Optional[str],
         typer.Option("--wrapper", "-w", help="Wrapper script (path or name from ~/.overcode/wrappers/)"),
     ] = None,
+    no_inherit: Annotated[
+        bool,
+        typer.Option(
+            "--no-inherit",
+            help="Don't inherit provider/model/wrapper/permissions from the parent agent (#433)",
+        ),
+    ] = False,
     sister: Annotated[
         Optional[str],
         typer.Option("--sister", "-S", help="Launch on a remote sister machine (by name from config)"),
@@ -278,22 +299,13 @@ def launch(
     # Parse oversight policy
     oversight_policy, oversight_timeout_seconds = _parse_oversight_policy(on_stuck, oversight_timeout)
 
-    # Resolve provider: CLI flag > config default > "web"
-    from ..config import get_new_agent_defaults
-    agent_defaults = get_new_agent_defaults()
-
-    resolved_provider = provider
-    if resolved_provider is None:
-        resolved_provider = agent_defaults.get("provider", "web")
-    if resolved_provider not in ("web", "bedrock"):
-        rprint(f"[red]Error: Invalid provider '{resolved_provider}'. Use: web, bedrock[/red]")
+    # Provider/wrapper resolution (CLI flag > parent settings > config
+    # default) happens in the launcher (#433); only validate the explicit
+    # flag here for a clean error message.
+    if provider is not None and provider not in ("web", "bedrock"):
+        rprint(f"[red]Error: Invalid provider '{provider}'. Use: web, bedrock[/red]")
         raise typer.Exit(code=1)
 
-    # Resolve wrapper: CLI flag > config default > None
-    resolved_wrapper = wrapper
-    if resolved_wrapper is None:
-        resolved_wrapper = agent_defaults.get("wrapper") or None
-
     # Default to current directory if not specified
     working_dir = directory if directory else os.getcwd()
 
@@ -312,8 +324,9 @@ def launch(
         budget_usd=budget,
         claude_agent=agent,
         model=model,
-        provider=resolved_provider,
-        wrapper=resolved_wrapper,
+        provider=provider,
+        wrapper=wrapper,
+        inherit_parent_settings=not no_inherit,
     )
 
     if result:
@@ -330,10 +343,12 @@ def launch(
             rprint(f"  Agent: {agent}")
         if teams:
             rprint("  Agent teams: enabled")
-        if resolved_wrapper:
-            rprint(f"  Wrapper: {resolved_wrapper}")
-        if resolved_provider != "web":
-            rprint(f"  Provider: {resolved_provider}")
+        if result.wrapper:
+            rprint(f"  Wrapper: {result.wrapper}")
+        if result.provider != "web":
+            rprint(f"  Provider: {result.provider}")
+        if result.model and not model:
+            rprint(f"  Model: {result.model} (inherited)")
         if budget is not None and budget > 0:
             rprint(f"  Budget: ${budget:.2f}")
 
@@ -451,7 +466,7 @@ def list_agents(
     """
     from ..history_reader import get_session_stats
     from ..tui_helpers import (
-        get_status_symbol, get_git_diff_stats,
+        get_status_symbol, get_git_diff_stats, get_git_untracked_count, effective_git_directory,
     )
     from ..monitor_daemon_state import get_monitor_daemon_state
     from ..summary_columns import build_cli_context, render_summary_cells, compute_column_widths, pad_and_join_cells, render_header_cells
@@ -578,24 +593,51 @@ def list_agents(
             claude_stats = synthesize_remote_stats(sess)
 
         git_diff = None
+        git_untracked = None
         if getattr(sess, 'is_remote', False):
             git_diff = getattr(sess, 'remote_git_diff', None)
+            git_untracked = getattr(sess, 'remote_git_untracked', None)
         else:
             try:
-                if sess.start_directory:
-                    git_diff = get_git_diff_stats(sess.start_directory)
+                _gdir = effective_git_directory(sess)
+                if _gdir:
+                    git_diff = get_git_diff_stats(_gdir)
+                    git_untracked = get_git_untracked_count(_gdir)
             except Exception:
                 pass
 
-        session_data.append((sess, status, activity, claude_stats, git_diff))
+        session_data.append((sess, status, activity, claude_stats, git_diff, git_untracked))
 
     # Compute cross-session flags
-    any_is_sleeping = any(st == "busy_sleeping" for _, st, _, _, _ in session_data)
+    any_is_sleeping = any(st == "busy_sleeping" for _, st, _, _, _, _ in session_data)
+
+    # Pull structured 2-column status detail off the detector when available
+    # (#TBD). Detector may be None when daemon state alone supplies status.
+    def _get_status_detail(sess):
+        if detector is None:
+            return None
+        getter = getattr(detector, "get_status_detail", None)
+        if getter is None:
+            return None
+        try:
+            return getter(sess.name)
+        except Exception:
+            return None
+
+    any_has_status_detail = any(
+        _get_status_detail(sd[0]) is not None for sd in session_data
+    )
+
+    # Heartbeat status legacy bridge (#TBD task 6)
+    from ..hook_status_detector import augment_with_legacy_heartbeat
+
+    def _augmented_detail(sess, status):
+        return augment_with_legacy_heartbeat(_get_status_detail(sess), status)
 
     # Second pass: build contexts and collect cells for auto-alignment
     all_cells = []
     activities = []
-    for sess, status, activity, claude_stats, git_diff in session_data:
+    for sess, status, activity, claude_stats, git_diff, git_untracked in session_data:
         meta = tree_meta.get(sess.id)
         child_count = meta.child_count if meta else 0
 
@@ -611,8 +653,11 @@ def list_agents(
             session=sess, stats=sess.stats,
             claude_stats=claude_stats, git_diff_stats=git_diff,
             status=status, bg_bash_count=0, live_sub_count=0,
+            git_untracked_count=git_untracked,
             any_has_budget=any_has_budget, child_count=child_count,
             any_is_sleeping=any_is_sleeping,
+            status_detail=_augmented_detail(sess, status),
+            any_has_status_detail=any_has_status_detail,
             any_has_oversight_timeout=any_has_oversight_timeout,
             oversight_deadline=oversight_deadline,
             pr_number=getattr(sess, 'pr_number', None),
@@ -656,6 +701,18 @@ def list_agents(
         line.truncate(console.width, pad=False)
         console.print(line, no_wrap=True)
 
+    # Warn if the terminal is too narrow to render the data columns — the
+    # right side is silently truncated otherwise, hiding metrics (#459).
+    data_width = sum(widths)
+    if data_width > console.width:
+        next_level = "med" if detail == "full" else "low"
+        suggest = f" Use --{next_level} for fewer columns." if detail != "low" else ""
+        rprint(
+            f"\n[yellow]⚠ Terminal is {console.width} cols; "
+            f"{data_width} needed for all columns — output truncated."
+            f"{suggest} Widen the terminal to see the rest.[/yellow]"
+        )
+
     if terminated_count > 0:
         rprint(f"\n[dim]{terminated_count} terminated session(s). Run 'overcode cleanup' to remove.[/dim]")
 
@@ -1084,8 +1141,10 @@ def show(
         stats_data = _gather_session_stats(sess, pane_content_raw)
         claude_stats = stats_data["claude_stats"]
         git_diff = stats_data["git_diff"]
+        git_untracked = stats_data["git_untracked"]
         bg_bash_count = stats_data["bg_bash_count"]
         live_sub_count = stats_data["live_sub_count"]
+        auto_accept = stats_data["auto_accept"]
 
         # AI summaries from daemon state
         ai_short = ""
@@ -1104,6 +1163,8 @@ def show(
             status=status,
             bg_bash_count=bg_bash_count,
             live_sub_count=live_sub_count,
+            git_untracked_count=git_untracked,
+            auto_accept_mode=auto_accept,
             any_has_budget=any_has_budget,
         )
 

overcode/cli/budget.py

@@ -99,6 +99,47 @@ def budget_transfer(
         raise typer.Exit(code=1)
 
 
+@budget_app.command("reclaim")
+def budget_reclaim(
+    name: Annotated[str, typer.Argument(help="Name of the child agent to reclaim from")],
+    session: SessionOption = "agents",
+):
+    """Refund a child agent's unused budget back to its parent (#432).
+
+    Use this for agents that died or crashed without posting a result. For
+    successful child completions the refund happens automatically when the
+    report is processed.
+
+    The refund is idempotent: a second call returns 0.
+
+    Examples:
+        overcode budget reclaim my-dead-child
+    """
+    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)
+
+    if not agent.parent_session_id:
+        rprint(f"[red]Error: '{name}' has no parent — nothing to reclaim to[/red]")
+        raise typer.Exit(code=1)
+
+    refunded = manager.reclaim_budget(agent.id)
+    if refunded is None:
+        rprint(f"[yellow]Nothing to reclaim from '{name}' (unlimited or missing parent)[/yellow]")
+        return
+    if refunded <= 0:
+        rprint(f"[yellow]'{name}' has spent its full budget — nothing to refund[/yellow]")
+        return
+
+    parent = manager.get_session(agent.parent_session_id)
+    parent_name = parent.name if parent else "(parent)"
+    rprint(f"[green]✓ Refunded ${refunded:.4f} from {name} to {parent_name}[/green]")
+
+
 @budget_app.command("show")
 def budget_show(
     name: Annotated[

overcode/cli/daemon.py

@@ -101,6 +101,17 @@ def monitor_daemon_status_cmd(session: SessionOption = "agents"):
     _monitor_daemon_status(session)
 
 
+def _format_loop_time_ago(last_loop_time: str) -> str:
+    """MonitorDaemonState timestamps are ISO strings; format_ago needs datetime."""
+    from datetime import datetime
+    from ..tui_helpers import format_ago
+
+    try:
+        return format_ago(datetime.fromisoformat(last_loop_time))
+    except (ValueError, TypeError):
+        return str(last_loop_time)
+
+
 def _monitor_daemon_status(session: str):
     """Internal function for showing monitor daemon status."""
     from ..monitor_daemon import is_monitor_daemon_running, get_monitor_daemon_pid
@@ -110,8 +121,7 @@ def _monitor_daemon_status(session: str):
         rprint(f"[dim]Monitor Daemon ({session}):[/dim] ○ stopped")
         state = get_monitor_daemon_state(session)
         if state and state.last_loop_time:
-            from ..tui_helpers import format_ago
-            rprint(f"  [dim]Last active: {format_ago(state.last_loop_time)}[/dim]")
+            rprint(f"  [dim]Last active: {_format_loop_time_ago(state.last_loop_time)}[/dim]")
         return
 
     pid = get_monitor_daemon_pid(session)
@@ -124,8 +134,7 @@ def _monitor_daemon_status(session: str):
         rprint(f"  Interval: {state.current_interval}s")
         rprint(f"  Sessions: {len(state.sessions)}")
         if state.last_loop_time:
-            from ..tui_helpers import format_ago
-            rprint(f"  Last loop: {format_ago(state.last_loop_time)}")
+            rprint(f"  Last loop: {_format_loop_time_ago(state.last_loop_time)}")
         if state.presence_available:
             rprint(f"  Presence: state={state.presence_state}, idle={state.presence_idle_seconds:.0f}s")
 

overcode/cli/focal.py

@@ -0,0 +1,76 @@
+"""
+`overcode focal-repo` — show or set the focal repo for a multi-repo agent (#170).
+"""
+
+from typing import Annotated, Optional
+
+import typer
+from rich import print as rprint
+
+from ._shared import app, SessionOption
+
+
+@app.command("focal-repo")
+def focal_repo(
+    name: Annotated[str, typer.Argument(help="Agent name")],
+    subdir: Annotated[
+        Optional[str],
+        typer.Argument(
+            help="Subdir to focus on. Pass `-` to clear. Omit to list candidates.",
+        ),
+    ] = None,
+    session: SessionOption = "agents",
+):
+    """Show or set the focal repo for a multi-repo workspace agent (#170).
+
+    With no subdir argument: lists the detected candidate repos and which
+    one (if any) is currently focal.
+
+    With a subdir: sets that subdir as the focal repo. Pass `-` to clear
+    the focal back to the workspace root.
+
+    For agents whose start_directory is itself a single git repo, this
+    command reports that there's nothing to cycle through.
+
+    Examples:
+        overcode focal-repo my-agent             # list
+        overcode focal-repo my-agent backend     # set focal
+        overcode focal-repo my-agent -           # clear focal
+    """
+    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)
+
+    candidates = manager.detect_focal_repo_candidates(agent.start_directory)
+    if not candidates:
+        rprint(
+            f"[yellow]'{name}' is a single-repo workspace at "
+            f"{agent.start_directory or '(no start dir)'} — nothing to focus.[/yellow]"
+        )
+        return
+
+    if subdir is None:
+        # List mode
+        rprint(f"[bold]{name}[/bold] focal candidates:")
+        for c in candidates:
+            marker = "→" if c == agent.focal_repo_subdir else " "
+            rprint(f"  {marker} {c}")
+        if not agent.focal_repo_subdir:
+            rprint("  [dim](no focal set — sampling start_directory directly)[/dim]")
+        return
+
+    # Set mode
+    if subdir == "-":
+        manager.set_focal_repo(agent.id, None)
+        rprint(f"[green]✓ Cleared focal repo for {name}[/green]")
+        return
+    try:
+        manager.set_focal_repo(agent.id, subdir)
+    except ValueError as e:
+        rprint(f"[red]{e}[/red]")
+        raise typer.Exit(code=1)
+    rprint(f"[green]✓ {name} focal repo: {subdir}[/green]")

overcode/cli/jobs.py

@@ -16,7 +16,7 @@ def bash(
     name: Annotated[Optional[str], typer.Option("--name", "-n", help="Job name (auto-derived if omitted)")] = None,
     directory: Annotated[str, typer.Option("--directory", "-d", help="Working directory")] = ".",
     agent: Annotated[Optional[str], typer.Option("--agent", "-a", help="Link to an agent session by name")] = None,
-    follow: Annotated[bool, typer.Option("--follow", "-f", help="Attach to the job's tmux window after launch")] = True,
+    follow: Annotated[bool, typer.Option("--follow/--no-follow", "-f", help="Attach to the job's tmux window after launch")] = True,
 ):
     """Launch a bash command as a tracked job."""
     import os

overcode/cli/monitoring.py

@@ -444,7 +444,6 @@ def export(
             rprint(f"  Presence rows: {result['presence_rows']}")
     except ImportError as e:
         rprint(f"[red]Error:[/red] {e}")
-        rprint("[dim]Install pyarrow: pip install pyarrow[/dim]")
         raise typer.Exit(1)
     except Exception as e:
         rprint(f"[red]Export failed:[/red] {e}")

overcode/cli/parallelism.py

@@ -0,0 +1,115 @@
+"""
+`overcode parallelism` — recommend a sensible max-children cap (#365).
+
+Computes a safe parallelism budget from system resources and current agent
+load. Useful as a guard before spawning more child agents from a parent.
+"""
+
+from typing import Annotated
+
+import typer
+from rich import print as rprint
+from rich.table import Table
+
+from ._shared import app, SessionOption
+
+
+# Heuristics — kept conservative because Claude children can spike well
+# above their idle footprint, and the user probably wants headroom for
+# the foreground app + supervision processes.
+_RESERVED_CORES = 1
+_PER_CHILD_RAM_GB = 1.5
+_PER_CHILD_CPU_FRACTION = 0.5  # assume each child saturates ~half a core sustained
+
+
+def _system_cores() -> int:
+    import os
+    return os.cpu_count() or 1
+
+
+def _system_ram_gb() -> float:
+    try:
+        import psutil  # type: ignore
+        return psutil.virtual_memory().total / (1024 ** 3)
+    except Exception:
+        # Fallback for systems without psutil — read sysconf if available.
+        try:
+            import os
+            pages = os.sysconf("SC_PHYS_PAGES")
+            page_size = os.sysconf("SC_PAGE_SIZE")
+            return (pages * page_size) / (1024 ** 3)
+        except (AttributeError, ValueError, OSError):
+            return 0.0
+
+
+def _recommend_cap(cores: int, ram_gb: float) -> int:
+    by_cpu = max(1, int((cores - _RESERVED_CORES) / _PER_CHILD_CPU_FRACTION))
+    by_ram = max(1, int(ram_gb / _PER_CHILD_RAM_GB)) if ram_gb > 0 else by_cpu
+    return min(by_cpu, by_ram)
+
+
+@app.command()
+def parallelism(
+    session: SessionOption = "agents",
+    json_out: Annotated[
+        bool,
+        typer.Option("--json", help="Emit recommendation as JSON for agents to consume"),
+    ] = False,
+):
+    """Recommend a max-children cap based on system resources and current load (#365).
+
+    Looks at CPU cores, total RAM, and the in-progress agents' resource
+    use, then prints a recommended ceiling and whether the current count
+    is safe. Use it as a quick sanity-check before launching more
+    children from a parent agent.
+    """
+    from ..launcher import ClaudeLauncher
+
+    launcher = ClaudeLauncher(session)
+    sessions = [
+        s for s in launcher.list_sessions(detect_terminated=False)
+        if s.status not in ("terminated", "done")
+    ]
+
+    cores = _system_cores()
+    ram_gb = _system_ram_gb()
+    recommended = _recommend_cap(cores, ram_gb)
+
+    current_count = len(sessions)
+    total_cpu_pct = sum((getattr(s, "cpu_percent", 0.0) or 0.0) for s in sessions)
+    total_ram_bytes = sum((getattr(s, "rss_bytes", 0) or 0) for s in sessions)
+    total_ram_gb = total_ram_bytes / (1024 ** 3)
+
+    headroom = max(0, recommended - current_count)
+    over = current_count > recommended
+
+    if json_out:
+        import json as _json
+        rprint(_json.dumps({
+            "cores": cores,
+            "ram_gb": round(ram_gb, 2),
+            "recommended_max_children": recommended,
+            "current_count": current_count,
+            "headroom": headroom,
+            "over_limit": over,
+            "current_total_cpu_pct": round(total_cpu_pct, 1),
+            "current_total_ram_gb": round(total_ram_gb, 2),
+        }))
+        return
+
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_row("[bold]System[/bold]", f"{cores} cores · {ram_gb:.1f} GB RAM")
+    table.add_row("[bold]Per-child budget[/bold]",
+                  f"≤{_PER_CHILD_CPU_FRACTION:.1f} core · ~{_PER_CHILD_RAM_GB:.1f} GB RAM")
+    table.add_row("[bold]Recommended max[/bold]", f"[green]{recommended}[/green] children")
+    table.add_row("[bold]Currently active[/bold]",
+                  f"{current_count} agents · {total_cpu_pct:.0f}% CPU · {total_ram_gb:.1f} GB RAM")
+    if over:
+        table.add_row("[bold]Verdict[/bold]",
+                      f"[red]Over by {current_count - recommended}[/red] — consider letting some finish before spawning more.")
+    elif headroom == 0:
+        table.add_row("[bold]Verdict[/bold]", "[yellow]At cap[/yellow] — no headroom for new children.")
+    else:
+        table.add_row("[bold]Verdict[/bold]",
+                      f"[green]OK[/green] — room for [bold]{headroom}[/bold] more children.")
+    rprint(table)

overcode/cli/split.py

@@ -32,6 +32,7 @@ from pathlib import Path
 from typing import Annotated
 
 import typer
+from rich import print as rprint
 
 from ._shared import app, SessionOption
 from ..tmux_utils import get_pane_base_index
@@ -397,14 +398,30 @@ def _setup_keybindings(linked_session: str = "", toggle_key: str = "") -> None:
             "if-shell -F '#{||:#{pane_in_mode},#{mouse_any_flag}}' "
             "'send-keys -M' 'copy-mode -e'",
         )
+        # Wheel-down on the bottom pane. We want to mirror wheel-up's
+        # 3-lines-per-tick rate while still exiting cleanly when the user
+        # scrolls back to the bottom.
+        #
+        # `send-keys -X -N 3 scroll-down` only works inside copy mode; out
+        # of copy mode it errors with "not in a mode" and tmux paints the
+        # status line, leaving the client looking frozen (#454). So for
+        # the local branch we gate on `pane_in_mode` of the linked
+        # session: in copy mode → scroll-down 3 lines (matches wheel-up);
+        # out of copy mode (already at the bottom) → NPage, a plain
+        # keystroke that's harmlessly delivered to the agent.
+        #
+        # SSH proxy branch keeps the unconditional NPage: we can't
+        # observe the remote tmux's mode from here, and NPage is safe in
+        # both states (page-down in remote copy mode, passthrough
+        # otherwise).
         _tmux(
             "bind-key", "-n", "WheelDownPane",
             "if-shell", "-F", _in_bottom,
-            # SSH proxy: send NPage to remote (works in copy mode).
-            # Local: send scroll-down in local copy mode.
             f'if-shell "{_ssh_check}" '
             f'"send-keys -t {linked_session} NPage" '
-            f'"send-keys -t {linked_session} -X -N 3 scroll-down"',
+            f'"if-shell -t {linked_session} -F \'#{{pane_in_mode}}\''
+            f' \'send-keys -t {linked_session} -X -N 3 scroll-down\''
+            f' \'send-keys -t {linked_session} NPage\'"',
             "send-keys -M",
         )
 
@@ -548,8 +565,6 @@ def tmux_layout(
     normally elsewhere, but they do override any custom user bindings for
     the same keys. Use --uninstall to remove them.
     """
-    from rich import print as rprint
-
     # --- Uninstall mode ---
     if uninstall:
         removed_anything = False
@@ -732,7 +747,9 @@ def _tmux_layout_locked(session: str, ratio: int, rprint, *, restart: bool = Fal
                       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)
+                from ..tmux_utils import _build_tmux_cmd
+                _cmd = [*_build_tmux_cmd(), "attach-session", "-t", oc_session]
+                os.execvp("tmux", _cmd)
             # Always restart the monitor so code changes take effect
             _tmux("respawn-pane", "-k",
                   "-t", f"{oc_session}:{SPLIT_WINDOW_NAME}.{get_pane_base_index()}",
@@ -904,4 +921,6 @@ def _tmux_layout_locked(session: str, ratio: int, rprint, *, restart: bool = Fal
         # Attach to the session (replaces this process)
         rprint(f"[green]Attaching to split layout...[/green]")
         time.sleep(0.2)
-        os.execlp("tmux", "tmux", "attach-session", "-t", oc_session)
+        from ..tmux_utils import _build_tmux_cmd
+        _cmd = [*_build_tmux_cmd(), "attach-session", "-t", oc_session]
+        os.execvp("tmux", _cmd)