overcode 0.3.0__tar.gz → 0.3.2__tar.gz

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

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

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

{overcode-0.3.0 → overcode-0.3.2}/src/overcode/bundled_skills.py

@@ -82,6 +82,26 @@ overcode send my-agent escape    # Reject permission
 overcode send my-agent "yes"     # Send text response
 ```
 
+## Jobs (Long-Running Bash Commands)
+
+For long-running commands (10min+ \u2014 test suites, builds, deploys), use `overcode bash` to launch them as tracked jobs in a separate tmux session. This keeps the output visible and lets you monitor multiple concurrent jobs from the TUI.
+
+```bash
+# Launch a job
+overcode bash "pytest tests/ -x" --name unit-tests
+overcode bash "npm run build" -d ~/frontend
+overcode bash "make deploy-staging" --agent my-agent   # Link to an agent
+
+# Manage jobs
+overcode jobs list [--all]        # List running (or all) jobs
+overcode jobs kill <name>         # Kill a running job
+overcode jobs attach <name>       # Attach to job's tmux window
+overcode jobs clear               # Remove completed/failed/killed jobs
+
+# TUI: press J to toggle jobs view, j/k to navigate, x to kill, c to clear
+overcode monitor --jobs           # Start TUI directly in jobs view
+```
+
 ## Standing Instructions Presets
 
 `overcode instruct <name> <preset>` \u2014 available presets: `DO_NOTHING`, `STANDARD`, `PERMISSIVE`, `CAUTIOUS`, `RESEARCH`, `CODING`, `TESTING`, `REVIEW`, `DEPLOY`, `AUTONOMOUS`, `MINIMAL`.
@@ -194,6 +214,30 @@ Pass arbitrary Claude CLI flags with `--claude-arg` (repeatable):
 overcode launch -n fast --claude-arg "--model haiku" --claude-arg "--effort low" -p "Quick review"
 ```
 
+## Long-Running Shell Commands (Jobs)
+
+When a task involves a long-running shell command (10min+ \u2014 full test suites, builds, deploys, docker compose), use `overcode bash` instead of running it inline. This launches the command as a tracked job in a separate tmux session with its own window, so you can monitor it without blocking your agent session.
+
+```bash
+# Launch a test suite as a tracked job
+overcode bash "pytest tests/ -x --timeout=600" --name full-tests
+
+# Launch a build linked to the current agent
+overcode bash "npm run build" --name frontend-build --agent my-agent
+
+# Check on it later
+overcode jobs list
+overcode jobs attach full-tests    # Attach to see live output
+overcode jobs kill full-tests      # Kill if needed
+```
+
+**When to use `overcode bash` vs running inline:**
+- Inline (`Bash` tool): Quick commands (<2 min) where you need the result to continue
+- `overcode bash`: Long commands (10min+) \u2014 test suites, builds, deploys, docker operations
+- `overcode launch`: When you need a full Claude Code agent with AI reasoning
+
+Jobs are visible in the TUI jobs view (press `J`) and auto-clean after 24h (configurable via `jobs.retention_hours` in config).
+
 ## Rules
 
 - Parent auto-detected from `OVERCODE_SESSION_NAME` \u2014 no `--parent` needed inside an overcode agent

{overcode-0.3.0 → overcode-0.3.2}/src/overcode/cli/__init__.py

@@ -22,6 +22,7 @@ from . import daemon  # noqa: F401
 from . import sister  # noqa: F401
 from . import config  # noqa: F401
 from . import split  # noqa: F401
+from . import jobs  # noqa: F401
 
 
 def main():

{overcode-0.3.0 → overcode-0.3.2}/src/overcode/cli/_shared.py

@@ -76,6 +76,14 @@ sister_app = typer.Typer(
 )
 app.add_typer(sister_app, name="sister")
 
+# Jobs subcommand group
+jobs_app = typer.Typer(
+    name="jobs",
+    help="Manage overcode jobs.",
+    no_args_is_help=True,
+)
+app.add_typer(jobs_app, name="jobs")
+
 # Config subcommand group
 config_app = typer.Typer(
     name="config",

{overcode-0.3.0 → overcode-0.3.2}/src/overcode/cli/agent.py

@@ -192,6 +192,10 @@ def launch(
         Optional[str],
         typer.Option("--allowed-tools", help="Comma-separated tools for Claude (e.g. 'Bash,Read,Write,Edit')"),
     ] = None,
+    model: Annotated[
+        Optional[str],
+        typer.Option("--model", "-m", help="Claude model (e.g. sonnet, opus, haiku, or full name)"),
+    ] = None,
     claude_args: Annotated[
         Optional[List[str]],
         typer.Option("--claude-arg", help="Extra Claude CLI flag (repeatable, e.g. '--model haiku')"),
@@ -283,6 +287,7 @@ def launch(
         agent_teams=teams,
         budget_usd=budget,
         claude_agent=agent,
+        model=model,
     )
 
     if result:
@@ -536,6 +541,9 @@ def list_agents(
             claude_stats = get_session_stats(sess)
         except Exception:
             pass
+        if claude_stats is None and getattr(sess, 'is_remote', False):
+            from ..history_reader import synthesize_remote_stats
+            claude_stats = synthesize_remote_stats(sess)
 
         git_diff = None
         if getattr(sess, 'is_remote', False):

overcode-0.3.2/src/overcode/cli/jobs.py

@@ -0,0 +1,156 @@
+"""
+CLI commands for managing overcode jobs.
+"""
+
+from typing import Annotated, Optional
+
+import typer
+from rich import print as rprint
+
+from ._shared import app, jobs_app
+
+
+@app.command()
+def bash(
+    command: Annotated[str, typer.Argument(help="Bash command to run as a tracked job")],
+    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,
+):
+    """Launch a bash command as a tracked job."""
+    import os
+    from ..job_launcher import JobLauncher
+    from ..session_manager import SessionManager
+
+    directory = os.path.abspath(directory)
+
+    agent_session_id = None
+    agent_name = None
+    # Auto-detect calling agent from env if --agent not specified
+    if not agent:
+        agent = os.environ.get("OVERCODE_SESSION_NAME")
+    if agent:
+        sm = SessionManager()
+        sess = sm.get_session_by_name(agent)
+        if sess:
+            agent_session_id = sess.id
+            agent_name = sess.name
+        else:
+            rprint(f"[yellow]Warning: Agent '{agent}' not found, launching without link[/yellow]")
+
+    launcher = JobLauncher()
+    job = launcher.launch(
+        command=command,
+        name=name,
+        directory=directory,
+        agent_session_id=agent_session_id,
+        agent_name=agent_name,
+    )
+
+    rprint(f"[green]✓[/green] Job '[bold]{job.name}[/bold]' launched")
+    rprint(f"  Command: {job.command}")
+    rprint(f"  Window: {job.tmux_session}:{job.tmux_window}")
+    if agent_name:
+        rprint(f"  Linked to agent: {agent_name}")
+
+    if follow:
+        launcher.attach(job.name)
+
+
+@jobs_app.command("list")
+def list_jobs(
+    all: Annotated[bool, typer.Option("--all", "-a", help="Include completed/failed/killed jobs")] = False,
+):
+    """List tracked jobs."""
+    from ..job_launcher import JobLauncher
+
+    launcher = JobLauncher()
+    jobs = launcher.list_jobs(include_completed=all)
+
+    if not jobs:
+        rprint("[dim]No jobs running[/dim]" if not all else "[dim]No jobs found[/dim]")
+        return
+
+    for job in sorted(jobs, key=lambda j: j.start_time, reverse=True):
+        status_icon = {
+            "running": "[green]●[/green]",
+            "completed": "[green]✓[/green]",
+            "failed": "[red]✗[/red]",
+            "killed": "[yellow]✗[/yellow]",
+        }.get(job.status, "?")
+
+        exit_str = ""
+        if job.exit_code is not None:
+            exit_str = f" ({job.exit_code})"
+
+        duration = ""
+        if job.start_time:
+            from datetime import datetime
+            try:
+                start = datetime.fromisoformat(job.start_time)
+                end = datetime.fromisoformat(job.end_time) if job.end_time else datetime.now()
+                dur_sec = (end - start).total_seconds()
+                mins, secs = divmod(int(dur_sec), 60)
+                duration = f"{mins}m{secs:02d}s"
+            except ValueError:
+                pass
+
+        agent_str = f" ← {job.agent_name}" if job.agent_name else ""
+        rprint(
+            f"  {status_icon} {job.name:<16} {job.command:<30} {duration:>8}   "
+            f"{job.status}{exit_str}{agent_str}"
+        )
+
+
+@jobs_app.command("kill")
+def kill_job(
+    name: Annotated[str, typer.Argument(help="Job name to kill")],
+):
+    """Kill a running job."""
+    from ..job_launcher import JobLauncher
+
+    launcher = JobLauncher()
+    if launcher.kill_job(name):
+        rprint(f"[green]✓[/green] Job '[bold]{name}[/bold]' killed")
+    else:
+        rprint(f"[red]✗[/red] Could not kill job '{name}' (not found or not running)")
+        raise typer.Exit(1)
+
+
+@jobs_app.command("attach")
+def attach_job(
+    name: Annotated[str, typer.Argument(help="Job name to attach to")],
+    bare: Annotated[bool, typer.Option("--bare", "-b", help="Attach with stripped tmux chrome")] = False,
+):
+    """Attach to a job's tmux window."""
+    from ..job_launcher import JobLauncher
+
+    launcher = JobLauncher()
+    try:
+        launcher.attach(name, bare=bare)
+    except ValueError as e:
+        rprint(f"[red]✗[/red] {e}")
+        raise typer.Exit(1)
+
+
+@jobs_app.command("clear")
+def clear_completed():
+    """Remove all completed/failed/killed jobs."""
+    from ..job_manager import JobManager
+
+    manager = JobManager()
+    manager.clear_completed()
+    rprint("[green]✓[/green] Cleared completed jobs")
+
+
+@jobs_app.command("_complete", hidden=True)
+def mark_complete(
+    job_id: Annotated[str, typer.Argument(help="Job ID")],
+    exit_code: Annotated[int, typer.Argument(help="Exit code")],
+):
+    """Internal: mark a job as complete (called by wrapper script)."""
+    from ..job_manager import JobManager
+
+    manager = JobManager()
+    manager.mark_complete(job_id, exit_code)

{overcode-0.3.0 → overcode-0.3.2}/src/overcode/cli/monitoring.py

@@ -273,6 +273,9 @@ def monitor(
     sync_target: Annotated[
         str, typer.Option("--sync-target", hidden=True, help="Linked tmux session for pane sync (set by `overcode split`)")
     ] = "",
+    jobs: Annotated[
+        bool, typer.Option("--jobs", help="Start in jobs view")
+    ] = False,
 ):
     """Launch the standalone TUI monitor."""
     if restart:
@@ -299,7 +302,7 @@ def monitor(
 
     from ..tui import run_tui
 
-    run_tui(session, diagnostics=diagnostics, sync_target=sync_target or None)
+    run_tui(session, diagnostics=diagnostics, sync_target=sync_target or None, initial_jobs_mode=jobs)
 
 
 @app.command()

{overcode-0.3.0 → 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:
@@ -191,7 +194,7 @@ def _remove_keybindings() -> None:
     from ..config import get_tmux_toggle_key
 
     toggle_key = get_tmux_toggle_key() or DEFAULT_TOGGLE_KEY
-    keys = [toggle_key, "M-j", "M-k", "PPage", "NPage", "WheelUpPane", "WheelDownPane"]
+    keys = [toggle_key, "M-j", "M-k", "M-b", "PPage", "NPage", "WheelUpPane", "WheelDownPane"]
     # Also unbind Tab if toggle_key changed away from it (stale binding)
     if toggle_key != "Tab":
         keys.append("Tab")
@@ -232,22 +235,30 @@ 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}.{_base} b",
+        "send-keys M-b",
+    )
 
     # --- Scrollback for the nested tmux in the bottom pane ---
     # The bottom pane runs a nested tmux client. The outer tmux
@@ -256,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",
         )
@@ -269,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",
         )
@@ -281,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",
@@ -403,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")
@@ -594,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
@@ -625,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
@@ -661,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
@@ -742,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:
@@ -750,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:
@@ -785,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.0 → overcode-0.3.2}/src/overcode/config.py

@@ -342,6 +342,19 @@ def save_new_agent_defaults(defaults: dict) -> None:
     save_config(config)
 
 
+def get_jobs_retention_hours() -> float:
+    """Get job retention period in hours.
+
+    Config format in ~/.overcode/config.yaml:
+        jobs:
+          retention_hours: 24
+
+    Returns:
+        Retention hours (default 24)
+    """
+    return float(_get_config_value("jobs.retention_hours", 24))
+
+
 def get_sisters_config() -> List[dict]:
     """Get sister instance configuration for cross-machine monitoring.
 

{overcode-0.3.0 → overcode-0.3.2}/src/overcode/history_reader.py

@@ -99,6 +99,28 @@ class ClaudeSessionStats:
         return sorted_times[n // 2]
 
 
+def synthesize_remote_stats(session) -> "ClaudeSessionStats":
+    """Synthesize ClaudeSessionStats for a remote session from daemon_state.
+
+    Remote sessions carry a remote_daemon_state dict with all
+    SessionDaemonState fields. Extract what we need so that render
+    columns (cost, tokens, context %, model) display correctly.
+    """
+    rds = getattr(session, 'remote_daemon_state', None) or {}
+    stats = session.stats
+    mwt = getattr(session, 'remote_median_work_time', None) or rds.get('median_work_time', 0.0)
+    return ClaudeSessionStats(
+        interaction_count=stats.interaction_count,
+        input_tokens=rds.get('input_tokens', stats.total_tokens),
+        output_tokens=rds.get('output_tokens', 0),
+        cache_creation_tokens=rds.get('cache_creation_tokens', 0),
+        cache_read_tokens=rds.get('cache_read_tokens', 0),
+        work_times=[mwt] if mwt > 0 else [],
+        current_context_tokens=rds.get('current_context_tokens', 0),
+        model=rds.get('model'),
+    )
+
+
 @dataclass
 class HistoryEntry:
     """A single interaction from Claude Code history."""

{overcode-0.3.0 → overcode-0.3.2}/src/overcode/implementations.py

@@ -235,6 +235,16 @@ class RealTmux:
         from .tmux_utils import attach_bare
         attach_bare(session, window)
 
+    def get_pane_pid(self, session: str, window: str) -> Optional[int]:
+        """Get the PID of the shell process in a window's first pane."""
+        try:
+            pane = self._get_pane(session, window)
+            if pane is None:
+                return None
+            return int(pane.pane_pid)
+        except (LibTmuxException, ValueError, TypeError):
+            return None
+
     def select_window(self, session: str, window: str) -> bool:
         """Select a window in a tmux session (for external pane sync)."""
         try:
@@ -246,6 +256,33 @@ class RealTmux:
         except LibTmuxException:
             return False
 
+    def resize_window(self, session: str, window: str, width: int, height: int) -> bool:
+        """Resize a tmux window to match terminal dimensions.
+
+        Used to fix window size mismatches when switching between sessions
+        after terminal resize (#245).
+
+        Args:
+            session: Session name
+            window: Window name/index
+            width: Target width in columns
+            height: Target height in rows
+
+        Returns:
+            True if resize succeeded, False otherwise
+        """
+        try:
+            # Use tmux resize-window command
+            # Format: session:window.pane
+            target = f"{session}:{window}"
+            result = self.run(
+                ["tmux", "resize-window", "-t", target, "-x", str(width), "-y", str(height)],
+                timeout=2
+            )
+            return result is not None and result.get("returncode") == 0
+        except Exception:
+            return False
+
 
 class RealFileSystem:
     """Production implementation of FileSystemInterface"""