overcode 0.5.3__tar.gz → 0.5.5__tar.gz

{overcode-0.5.3/src/overcode.egg-info → overcode-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overcode
-Version: 0.5.3
+Version: 0.5.5
 Summary: A supervisor for managing multiple Claude Code instances in tmux
 Author: Mike Bond
 Project-URL: Homepage, https://github.com/mkb23/overcode
@@ -176,7 +176,7 @@ See the [TUI Guide](docs/tui-guide.md) for all keyboard shortcuts.
 - [TUI Guide](docs/tui-guide.md) - Keyboard shortcuts and display modes
 - [Configuration](docs/configuration.md) - Config file and environment variables
 - [Wrappers](docs/wrappers.md) - Run agents in containers and custom environments
-- [Advanced Features](docs/advanced-features.md) - Sleep mode, handover, remote monitoring
+- [Advanced Features](docs/advanced-features.md) - Sleep mode, remote monitoring
 
 ## Testing
 

{overcode-0.5.3 → overcode-0.5.5}/README.md

@@ -134,7 +134,7 @@ See the [TUI Guide](docs/tui-guide.md) for all keyboard shortcuts.
 - [TUI Guide](docs/tui-guide.md) - Keyboard shortcuts and display modes
 - [Configuration](docs/configuration.md) - Config file and environment variables
 - [Wrappers](docs/wrappers.md) - Run agents in containers and custom environments
-- [Advanced Features](docs/advanced-features.md) - Sleep mode, handover, remote monitoring
+- [Advanced Features](docs/advanced-features.md) - Sleep mode, remote monitoring
 
 ## Testing
 

{overcode-0.5.3 → overcode-0.5.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "overcode"
-version = "0.5.3"
+version = "0.5.5"
 description = "A supervisor for managing multiple Claude Code instances in tmux"
 authors = [
     {name = "Mike Bond"}
@@ -61,7 +61,7 @@ export = [
 ]
 
 [project.scripts]
-overcode = "overcode.cli:main"
+overcode = "overcode.entrypoint:main"
 tui-eye = "overcode.testing.tui_eye:main"
 
 [tool.setuptools.packages.find]

{overcode-0.5.3 → overcode-0.5.5}/src/overcode/backends/opencode.py

@@ -14,7 +14,10 @@ remains the fallback for a launch where the plugin could not be installed.
 Everything below the flag table was captured from a real opencode
 v1.18.19 session; the pane corpus lives in
 ``tests/fixtures_opencode_panes/`` and is replayed by
-``tests/unit/test_status_detector_opencode.py``.
+``tests/unit/test_status_detector_opencode.py``. Re-verified unchanged
+against v1.18.29 (Sep 2026, #474): a second pane corpus under
+``tests/fixtures_opencode_panes/v1.18.29/`` and the plugin's event-stream
+corpus in ``tests/fixtures_opencode_events/``.
 """
 
 import json

{overcode-0.5.3 → overcode-0.5.5}/src/overcode/backends/opencode2_stats.py

@@ -60,7 +60,9 @@ from ..stats_reader import (
 from .opencode_stats import (
     _as_float,
     _as_int,
+    _cached_records,
     _launch_ms,
+    _optional_ms,
     _parse_model,
     _placeholders,
     _table_columns,
@@ -216,6 +218,69 @@ def _row_identities(rows: Sequence[sqlite3.Row]) -> Tuple[Optional[str], Optiona
     return _parse_model(active["model"]), (active["agent"] or None)
 
 
+def _scan_sql(ids: Sequence[str]) -> Tuple[str, List[Any]]:
+    """The newest ``_MESSAGE_SCAN_LIMIT`` user/assistant rows of each
+    conversation — narrow columns only, unordered across conversations.
+
+    One bounded probe per conversation rather than one ``session_id IN
+    (...) ORDER BY ... LIMIT`` over all of them — the shared sort's cost
+    grew roughly quadratically with the number of owned ids (#476; the v1
+    reader's ``_scan_sql`` has the numbers). Inside one conversation
+    ``seq`` is assigned in insertion order, so ``ORDER BY seq DESC`` on the
+    unique ``(session_id, seq)`` index yields exactly the newest rows
+    without a sort; the caller merges by ``(time_created, seq)`` in Python.
+
+    ``data`` is deliberately not selected: on a real store an assistant
+    row carries its tool output inline (1 KB-1 MB); bodies are fetched
+    once per version through ``opencode_stats._cached_records``.
+    """
+    probe = (
+        "SELECT * FROM (SELECT id, session_id, type, seq, time_created, "
+        "time_updated FROM session_message WHERE session_id = ? "
+        "AND type IN ('user', 'assistant') ORDER BY seq DESC LIMIT ?)"
+    )
+    sql = " UNION ALL ".join([probe] * len(ids))
+    params: List[Any] = []
+    for sid in ids:
+        params.extend((sid, _MESSAGE_SCAN_LIMIT))
+    return sql, params
+
+
+def _parse_session_message_record(
+    data: Optional[str], mtype: Any
+) -> Tuple[Optional[Dict[str, Any]], bool]:
+    """Extract what the scan needs from a v2 ``session_message.data`` body.
+
+    ``mtype`` is the row's ``type`` column (the envelope has no role).
+    """
+    try:
+        envelope = json.loads(data) if data is not None else None
+    except (ValueError, TypeError):
+        return None, False
+    if not isinstance(envelope, dict):
+        return None, False
+    tokens = envelope.get("tokens")
+    tokens = tokens if isinstance(tokens, dict) else {}
+    cache = tokens.get("cache")
+    cache = cache if isinstance(cache, dict) else {}
+    times = envelope.get("time")
+    times = times if isinstance(times, dict) else {}
+    agent = envelope.get("agent")
+    record = {
+        "input": _as_int(tokens.get("input")),
+        "output": _as_int(tokens.get("output")),
+        "reasoning": _as_int(tokens.get("reasoning")),
+        "cache_read": _as_int(cache.get("read")),
+        "cache_write": _as_int(cache.get("write")),
+        "created": _optional_ms(times.get("created")),
+        "completed": _optional_ms(times.get("completed")),
+        "model": _parse_model(envelope.get("model")),
+        "agent": agent if isinstance(agent, str) and agent else None,
+    }
+    in_flight = mtype == "assistant" and record["completed"] is None
+    return record, not in_flight
+
+
 def _scan_messages(
     conn: sqlite3.Connection,
     session_ids: Sequence[str],
@@ -246,24 +311,22 @@ def _scan_messages(
     if not ids:
         return out
 
-    sql = (
-        "SELECT id, session_id, type, time_created, data FROM session_message "
-        f"WHERE session_id IN ({_placeholders(len(ids))}) "
-        "AND type IN ('user', 'assistant') "
-        "ORDER BY time_created DESC, seq DESC LIMIT ?"
-    )
+    sql, params = _scan_sql(ids)
     try:
-        rows = conn.execute(sql, (*ids, _MESSAGE_SCAN_LIMIT * max(1, len(ids)))).fetchall()
+        rows = conn.execute(sql, params).fetchall()
+        rows.sort(key=lambda row: (row[4], row[3]), reverse=True)
+        records = _cached_records(
+            conn, "session_message",
+            [(row[0], row[5], row[2]) for row in rows],
+            _parse_session_message_record,
+        )
     except sqlite3.Error:
         return out
 
     seen_context = False
-    for _msg_id, session_id, mtype, time_created, data in rows:
-        try:
-            envelope = json.loads(data)
-        except (ValueError, TypeError):
-            continue
-        if not isinstance(envelope, dict):
+    for msg_id, session_id, mtype, _seq, time_created, _updated in rows:
+        record = records.get(msg_id)
+        if record is None:
             continue
         if mtype == "user":
             out["interaction_count"] += 1
@@ -271,22 +334,13 @@ def _scan_messages(
         if mtype != "assistant":
             continue
 
-        tokens = envelope.get("tokens")
-        tokens = tokens if isinstance(tokens, dict) else {}
-        cache = tokens.get("cache")
-        cache = cache if isinstance(cache, dict) else {}
-
         # v2's assistant data has no `tokens.total` (verified); the context
         # size is the processed prompt — input + cache read + cache write —
         # the semantics AgentSessionStats.current_context_tokens documents.
         # Rows arrive newest-first, and only the active conversation's
         # context is meaningful — an older /new session's is stale.
         if not seen_context and (active_id is None or session_id == active_id):
-            context = (
-                _as_int(tokens.get("input"))
-                + _as_int(cache.get("read"))
-                + _as_int(cache.get("write"))
-            )
+            context = record["input"] + record["cache_read"] + record["cache_write"]
             if context > 0:
                 out["current_context_tokens"] = context
                 seen_context = True
@@ -296,32 +350,24 @@ def _scan_messages(
         # tracked session's identities must not leak into the active
         # conversation.
         if active_id is not None and session_id == active_id:
-            if out["model"] is None:
-                parsed_model = _parse_model(envelope.get("model"))
-                if parsed_model:
-                    out["model"] = parsed_model
-            if out["agent"] is None:
-                agent = envelope.get("agent")
-                if isinstance(agent, str) and agent:
-                    out["agent"] = agent
-
-        times = envelope.get("time")
-        times = times if isinstance(times, dict) else {}
-        created = times.get("created")
-        completed = times.get("completed")
-        if isinstance(created, (int, float)) and isinstance(completed, (int, float)):
+            if out["model"] is None and record["model"]:
+                out["model"] = record["model"]
+            if out["agent"] is None and record["agent"]:
+                out["agent"] = record["agent"]
+
+        created = record["created"]
+        completed = record["completed"]
+        if created is not None and completed is not None:
             elapsed = (completed - created) / 1000.0
             if elapsed > 0:
                 out["work_times"].append(elapsed)
 
         if since_ms is not None and _as_int(time_created) >= since_ms:
             window = out["window"]
-            window["input_tokens"] += _as_int(tokens.get("input"))
-            window["output_tokens"] += _as_int(tokens.get("output")) + _as_int(
-                tokens.get("reasoning")
-            )
-            window["cache_creation_tokens"] += _as_int(cache.get("write"))
-            window["cache_read_tokens"] += _as_int(cache.get("read"))
+            window["input_tokens"] += record["input"]
+            window["output_tokens"] += record["output"] + record["reasoning"]
+            window["cache_creation_tokens"] += record["cache_write"]
+            window["cache_read_tokens"] += record["cache_read"]
 
     out["work_times"].reverse()
     return out

{overcode-0.5.3 → overcode-0.5.5}/src/overcode/backends/opencode_stats.py

@@ -26,9 +26,10 @@ daemon tick.
 import json
 import os
 import sqlite3
+import threading
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Sequence, Tuple
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
 
 from .. import model_metadata
 from ..stats_reader import (
@@ -323,6 +324,159 @@ def fetch_rows_for_directory(
     return conn.execute(sql, (*candidates, since_ms)).fetchall()
 
 
+def _scan_sql(ids: Sequence[str]) -> Tuple[str, List[Any]]:
+    """The newest ``_MESSAGE_SCAN_LIMIT`` rows of each conversation — narrow
+    columns only, unordered across conversations.
+
+    One bounded probe per conversation, not one ``WHERE session_id IN (...)
+    ORDER BY ... LIMIT`` over all of them: SQLite answers the latter through
+    a temp B-tree fed by every candidate row, so its cost grew roughly
+    quadratically with the number of owned ids (~2 ms at one, ~115 ms at
+    eight on a real store — per agent, per second, for the burn rate; #476).
+    Each probe here walks the ``(session_id, time_created)`` index backwards
+    and stops at its own limit, which is also what the per-session scan
+    limit documents. The caller merges in Python: an SQL ``ORDER BY`` over
+    the union would materialise every row again.
+
+    ``data`` is deliberately not selected — see ``_cached_records``.
+    """
+    probe = (
+        "SELECT * FROM (SELECT id, session_id, time_created, time_updated "
+        "FROM message WHERE session_id = ? ORDER BY time_created DESC LIMIT ?)"
+    )
+    sql = " UNION ALL ".join([probe] * len(ids))
+    params: List[Any] = []
+    for sid in ids:
+        params.extend((sid, _MESSAGE_SCAN_LIMIT))
+    return sql, params
+
+
+# Per-row parse cache (#476). The TUI re-reads a conversation's newest rows
+# every second for the burn rate and every 5 s for the stats columns, and
+# on a real store an assistant row is 1 KB-1 MB of JSON (tool output
+# travels inline). So the scan selects only the narrow columns — they all
+# sit in the row's first page, so it never touches overflow pages — and
+# fetches + parses ``data`` only for rows it has not seen at that
+# ``time_updated``. opencode rewrites ``time_updated`` whenever it rewrites
+# a row (on a live store an assistant row's ``time_updated`` is its
+# ``time.completed``); an assistant row still in flight (no
+# ``time.completed`` yet) is never cached, so a stale key cannot freeze it.
+# Entries are small extracted records, never the envelope.
+_ROW_CACHE_MAX = 50_000
+_row_cache: Dict[Tuple[str, str, str], Tuple[Any, Any]] = {}
+_row_cache_lock = threading.Lock()
+
+# A parsed row: the record the scan consumes, and whether it may be cached.
+RowParser = Callable[[Optional[str], Any], Tuple[Optional[Dict[str, Any]], bool]]
+
+
+def clear_row_cache() -> None:
+    """Drop every cached row record (tests)."""
+    with _row_cache_lock:
+        _row_cache.clear()
+
+
+def _database_key(conn: sqlite3.Connection) -> str:
+    """The file behind ``conn`` — cache entries must not cross stores."""
+    try:
+        for _seq, name, file in conn.execute("PRAGMA database_list"):
+            if name == "main":
+                return file or ""
+    except sqlite3.Error:
+        pass
+    return ""
+
+
+def _fetch_data(
+    conn: sqlite3.Connection, table: str, ids: Sequence[str]
+) -> Dict[str, str]:
+    """``data`` for the given row ids, by primary key."""
+    out: Dict[str, str] = {}
+    for start in range(0, len(ids), 500):
+        chunk = list(ids[start : start + 500])
+        sql = f"SELECT id, data FROM {table} WHERE id IN ({_placeholders(len(chunk))})"
+        for msg_id, data in conn.execute(sql, chunk):
+            out[msg_id] = data
+    return out
+
+
+def _cached_records(
+    conn: sqlite3.Connection,
+    table: str,
+    rows: Sequence[Tuple[str, Any, Any]],
+    parse: RowParser,
+) -> Dict[str, Optional[Dict[str, Any]]]:
+    """Records for ``rows`` of ``(id, time_updated, hint)``, parsed at most
+    once per ``(store, table, id, time_updated)``.
+
+    ``hint`` is handed to ``parse`` alongside the body (v2 keeps the row
+    type outside the envelope). Unparseable rows map to None.
+    """
+    db = _database_key(conn)
+    records: Dict[str, Optional[Dict[str, Any]]] = {}
+    missing: List[Tuple[str, Any, Any]] = []
+    for msg_id, version, hint in rows:
+        entry = _row_cache.get((db, table, msg_id))
+        if entry is not None and entry[0] == version:
+            records[msg_id] = entry[1]
+        else:
+            missing.append((msg_id, version, hint))
+    if not missing:
+        return records
+
+    bodies = _fetch_data(conn, table, [msg_id for msg_id, _, _ in missing])
+    fresh: Dict[Tuple[str, str, str], Tuple[Any, Any]] = {}
+    for msg_id, version, hint in missing:
+        record, cacheable = parse(bodies.get(msg_id), hint)
+        records[msg_id] = record
+        if cacheable:
+            fresh[(db, table, msg_id)] = (version, record)
+    if fresh:
+        with _row_cache_lock:
+            if len(_row_cache) + len(fresh) > _ROW_CACHE_MAX:
+                # Bound growth: drop the oldest half (insertion order).
+                for stale in list(_row_cache)[: _ROW_CACHE_MAX // 2]:
+                    del _row_cache[stale]
+            _row_cache.update(fresh)
+    return records
+
+
+def _optional_ms(value: Any) -> Optional[float]:
+    return value if isinstance(value, (int, float)) else None
+
+
+def _parse_message_record(
+    data: Optional[str], _hint: Any
+) -> Tuple[Optional[Dict[str, Any]], bool]:
+    """Extract what the scan needs from a v1 ``message.data`` envelope."""
+    try:
+        envelope = json.loads(data) if data is not None else None
+    except (ValueError, TypeError):
+        return None, False
+    if not isinstance(envelope, dict):
+        return None, False
+    tokens = envelope.get("tokens")
+    tokens = tokens if isinstance(tokens, dict) else {}
+    cache = tokens.get("cache")
+    cache = cache if isinstance(cache, dict) else {}
+    times = envelope.get("time")
+    times = times if isinstance(times, dict) else {}
+    role = envelope.get("role")
+    record = {
+        "role": role,
+        "total": _as_int(tokens.get("total")),
+        "input": _as_int(tokens.get("input")),
+        "output": _as_int(tokens.get("output")),
+        "reasoning": _as_int(tokens.get("reasoning")),
+        "cache_read": _as_int(cache.get("read")),
+        "cache_write": _as_int(cache.get("write")),
+        "created": _optional_ms(times.get("created")),
+        "completed": _optional_ms(times.get("completed")),
+    }
+    in_flight = role == "assistant" and record["completed"] is None
+    return record, not in_flight
+
+
 def _scan_messages(
     conn: sqlite3.Connection,
     session_ids: Sequence[str],
@@ -345,64 +499,53 @@ def _scan_messages(
     if not ids:
         return out
 
-    sql = (
-        "SELECT id, session_id, time_created, data FROM message "
-        f"WHERE session_id IN ({_placeholders(len(ids))}) "
-        "ORDER BY time_created DESC LIMIT ?"
-    )
+    sql, params = _scan_sql(ids)
     try:
-        rows = conn.execute(sql, (*ids, _MESSAGE_SCAN_LIMIT * max(1, len(ids)))).fetchall()
+        rows = conn.execute(sql, params).fetchall()
+        rows.sort(key=lambda row: row[2], reverse=True)  # time_created DESC
+        records = _cached_records(
+            conn, "message", [(row[0], row[3], None) for row in rows],
+            _parse_message_record,
+        )
     except sqlite3.Error:
         return out
 
     seen_context = False
-    for _msg_id, session_id, time_created, data in rows:
-        try:
-            envelope = json.loads(data)
-        except (ValueError, TypeError):
+    for msg_id, session_id, time_created, _updated in rows:
+        record = records.get(msg_id)
+        if record is None:
             continue
-        if not isinstance(envelope, dict):
-            continue
-        role = envelope.get("role")
+        role = record["role"]
         if role == "user":
             out["interaction_count"] += 1
             continue
         if role != "assistant":
             continue
 
-        tokens = envelope.get("tokens")
-        tokens = tokens if isinstance(tokens, dict) else {}
-        cache = tokens.get("cache")
-        cache = cache if isinstance(cache, dict) else {}
-
         # Rows arrive newest-first, so the first assistant turn carrying a
         # total is the live context size. Only the active conversation's
         # context is meaningful — an older /new session's is stale.
         if (
             not seen_context
-            and tokens.get("total")
+            and record["total"]
             and (active_id is None or session_id == active_id)
         ):
-            out["current_context_tokens"] = _as_int(tokens.get("total"))
+            out["current_context_tokens"] = record["total"]
             seen_context = True
 
-        times = envelope.get("time")
-        times = times if isinstance(times, dict) else {}
-        created = times.get("created")
-        completed = times.get("completed")
-        if isinstance(created, (int, float)) and isinstance(completed, (int, float)):
+        created = record["created"]
+        completed = record["completed"]
+        if created is not None and completed is not None:
             elapsed = (completed - created) / 1000.0
             if elapsed > 0:
                 out["work_times"].append(elapsed)
 
         if since_ms is not None and _as_int(time_created) >= since_ms:
             window = out["window"]
-            window["input_tokens"] += _as_int(tokens.get("input"))
-            window["output_tokens"] += _as_int(tokens.get("output")) + _as_int(
-                tokens.get("reasoning")
-            )
-            window["cache_creation_tokens"] += _as_int(cache.get("write"))
-            window["cache_read_tokens"] += _as_int(cache.get("read"))
+            window["input_tokens"] += record["input"]
+            window["output_tokens"] += record["output"] + record["reasoning"]
+            window["cache_creation_tokens"] += record["cache_write"]
+            window["cache_read_tokens"] += record["cache_read"]
 
     out["work_times"].reverse()
     return out
@@ -697,6 +840,7 @@ def _launch_ms(session: Any) -> Optional[int]:
 
 __all__ = [
     "EXPECTED_MESSAGE_COLUMNS",
+    "clear_row_cache",
     "EXPECTED_SESSION_COLUMNS",
     "OpencodeStatsReader",
     "connect",

{overcode-0.5.3 → overcode-0.5.5}/src/overcode/cli/_shared.py

@@ -109,6 +109,24 @@ app.add_typer(models_app, name="models")
 
 # Console for rich output
 console = Console()
+# Notices that must not mix into output a script may parse
+err_console = Console(stderr=True)
+
+
+def find_agent(manager, name: str):
+    """Look up the agent ``name`` addresses, following renames (#478).
+
+    ``manager`` is a SessionManager. When ``name`` is an agent's old name,
+    the agent is returned and a one-line notice goes to stderr, so a person
+    or script still using the old name learns the new one.
+    """
+    from ..session_manager import rename_notice
+
+    session = manager.resolve_session_name(name)
+    notice = rename_notice(name, session)
+    if notice:
+        err_console.print(f"[yellow]{notice}[/yellow]")
+    return session
 
 # Global session option (hidden advanced usage)
 SessionOption = Annotated[