omega-code 0.4.0__py3-none-any.whl

omega/ui/tui/app.py

@@ -0,0 +1,958 @@
+"""OmegaApp: composition, key bindings, and turn execution. Rendering logic
+lives in transcript.py/sidebar.py/status.py; this module only translates
+events into calls on their typed widget methods, never the reverse."""
+from __future__ import annotations
+
+import asyncio
+import difflib
+import time
+from pathlib import Path
+from typing import Any, cast
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.events import Key, Paste, Resize
+from textual.screen import ModalScreen
+from textual.timer import Timer
+from textual.widgets import Static, TextArea
+from textual.worker import Worker
+
+from ... import compact, config, events, export, gitlog, loop, session, trace
+from ...memory import consolidate
+from .. import composer as composer_lib
+from .. import format
+from . import prefs, theme
+from .history import InputHistory
+from .modals import AskUserScreen, ConfirmScreen, DiffScreen, ModelPickerScreen, SessionsScreen
+from .sidebar import Sidebar
+from .status import StatusBar, StatusState
+from .transcript import Transcript
+
+_MODE_ROLE = {"build": "main", "plan": "plan", "discuss": "discuss"}
+_MODE_TAG_STYLE = {"build": "dim", "plan": "yellow", "discuss": "$accent"}
+_MODE_CYCLE = ["build", "plan", "discuss"]
+
+# Below this total terminal width the side panel is auto-hidden (regardless
+# of the user's own toggle preference) rather than squeezed down to
+# illegibility -- `Sidebar`'s own `max-width: 40%` still applies above it.
+_MIN_WIDTH_FOR_SIDEBAR = 80
+
+_COMMANDS = ["/plan", "/build", "/discuss", "/mode", "/memory-gc", "/model", "/sidebar",
+            "/theme", "/cost", "/export", "/compact", "/undo", "/diff", "/verify",
+            "/sessions", "/help", "/quit"]
+
+_HELP_TEXT = (
+    "ctrl+c cancel turn  ·  ctrl+o /model switch model  ·  ctrl+b toggle side panel  ·  "
+    "shift+tab cycle mode\n"
+    "ctrl+1/2/3 or [ ] switch side-panel tab  ·  up/down input history\n"
+    "input line editing: ctrl+u clear line  ·  ctrl+w/alt+backspace delete word back  ·  "
+    "alt+d delete word forward\n"
+    "ctrl+k delete to end  ·  ctrl+a/ctrl+e home/end  ·  alt+left/right word jump  ·  "
+    "esc clear input (idle only)\n"
+    "/plan /build /discuss switch modes  ·  /model <alias>  ·  /mode  ·  /sidebar  ·  "
+    "/theme system|light|dark  ·  /memory-gc\n"
+    "/cost tokens & $  ·  /export [path]  ·  /compact  ·  /undo [n]  ·  /diff  ·  /verify  ·  "
+    "/sessions  ·  /quit")
+
+# `events.Checkpoint`/`Verified`/`JobStarted`/`JobFinished` are B1's, added to
+# events.py concurrently with this file -- resolved once at import time so
+# `emit()` below can dispatch to them without a hard import dependency.
+_Checkpoint = getattr(events, "Checkpoint", None)
+_Verified = getattr(events, "Verified", None)
+_JobStarted = getattr(events, "JobStarted", None)
+_JobFinished = getattr(events, "JobFinished", None)
+
+# Git branch per cwd, cached for the life of the process and refreshed
+# explicitly at turn end -- a `git symbolic-ref` per header repaint would be
+# wasteful for something that only ever changes between turns.
+_branch_cache: dict[str, str] = {}
+
+
+async def _lookup_branch(cwd: str) -> str:
+    path = Path(cwd)
+    for d in (path, *path.parents):
+        if (d / ".git").exists():
+            return await asyncio.to_thread(gitlog._branch, d)
+    return ""
+
+
+class HeaderBar(Static):
+    """The top chrome line: wordmark, cwd, git branch, session id -- all dim
+    but the wordmark (Part R9).
+
+    Fixed at `height: 1`, and rich's default word-wrap can push an
+    over-length "word" (an unbroken path has no internal spaces to wrap on)
+    onto a second line wholesale rather than character-cropping it -- with
+    height pinned to 1, that pushed-down line is never shown, so the entire
+    cwd/branch/session tail could silently vanish the moment it didn't fit.
+    Truncating the tail ourselves, from the right, against the bar's actual
+    width keeps this a single guaranteed-fitting line instead."""
+
+    DEFAULT_CSS = """
+    HeaderBar { height: 2; color: $text-muted; padding: 0 1; }
+    """
+
+    _PREFIX = "⌘ omega  "
+
+    def __init__(self, *, id: str | None = None) -> None:
+        super().__init__(id=id)
+        self._cwd = ""
+        self._branch = ""
+        self._session_id = ""
+
+    def set_state(self, cwd: str, branch: str, session_id: str) -> None:
+        self._cwd, self._branch, self._session_id = cwd, branch, session_id
+        self._repaint()
+
+    def on_resize(self, event: Resize) -> None:
+        self._repaint()
+
+    def _repaint(self) -> None:
+        # Branch and session id are short and the most useful thing to keep
+        # legible -- only the (already-abbreviated) cwd gets truncated
+        # further when space is tight, rather than right-cropping the whole
+        # joined line and risking the session id being the part that's lost.
+        suffix_bits = [self._branch] if self._branch else []
+        suffix_bits.append(self._session_id)
+        suffix = " · " + " · ".join(suffix_bits)
+        cwd = format.abbrev_cwd(self._cwd)
+        width = self.content_size.width
+        if width:
+            cwd = format.truncate_right(cwd, max(0, width - len(self._PREFIX) - len(suffix)))
+            # Even an unabbreviated branch/session id alone can outrun a very
+            # narrow pane -- a last-resort truncation of the whole tail keeps
+            # this row guaranteed to fit rather than leaning on the engine's
+            # own (ellipsis-less) overflow clipping.
+            tail = format.truncate_right(f"{cwd}{suffix}", width - len(self._PREFIX))
+        else:
+            tail = f"{cwd}{suffix}"
+        rule = "─" * max(1, width or 40)
+        self.update(f"[bold]⌘ omega[/bold]  [dim]{format.esc(tail)}[/dim]\n[$rule]{rule}[/$rule]")
+
+
+class PromptInput(TextArea):
+    """The `#prompt` composer. A real multiline editor (Textual `TextArea`)
+    so you can see which line you're on, insert newlines, and paste a block
+    without it collapsing to one line.
+
+    Submit is Enter (empty-line-at-end also works via the usual "send").
+    Shift+Enter / Alt+Enter / Ctrl+J insert a newline. Escape clears only
+    when idle. Up/down walk input history when the caret is on the first/
+    last line; otherwise they move the caret.
+
+    Word-delete is bound on every key a terminal can actually deliver for it
+    -- `ctrl+w`, `alt+backspace` and `ctrl+backspace`. `cmd`-chords are not
+    among them: macOS reserves the Command modifier for the window manager.
+    """
+
+    BINDINGS = [
+        *TextArea.BINDINGS,
+        Binding("enter", "submit", show=False, priority=True),
+        Binding("shift+enter", "newline", show=False, priority=True),
+        Binding("alt+enter", "newline", show=False, priority=True),
+        Binding("ctrl+j", "newline", show=False, priority=True),
+        Binding("alt+left", "cursor_word_left", show=False),
+        Binding("alt+right", "cursor_word_right", show=False),
+        Binding("alt+d", "delete_word_right", show=False),
+        Binding("escape", "clear_when_idle", show=False, priority=True),
+        Binding("up", "history_or_up", show=False, priority=True),
+        Binding("down", "history_or_down", show=False, priority=True),
+        Binding("tab", "mention_or_tab", show=False, priority=True),
+    ]
+
+    def __init__(self, **kwargs: Any) -> None:
+        placeholder = kwargs.pop("placeholder", "")
+        super().__init__(
+            "",
+            language=None,
+            soft_wrap=True,
+            tab_behavior="indent",
+            show_line_numbers=False,
+            compact=True,
+            highlight_cursor_line=True,
+            placeholder=placeholder,
+            **kwargs,
+        )
+        self._mention_hits: list[str] = []
+        self._mention_index = 0
+        self._box_min = 3
+        self._box_max = 10
+
+    # Tests and the rest of OmegaApp still talk to `.value` like the old Input.
+    @property
+    def value(self) -> str:
+        return self.text
+
+    @value.setter
+    def value(self, text: str) -> None:
+        self.text = text
+        self.move_cursor(self.document.end)
+        self._sync_box_height()
+
+    def action_end(self) -> None:
+        self.move_cursor(self.document.end)
+
+    def action_newline(self) -> None:
+        self.insert("\n")
+        self._sync_box_height()
+
+    def action_submit(self) -> None:
+        if self._try_accept_mention():
+            return
+        cast("OmegaApp", self.app)._submit_prompt()
+
+    def action_clear_when_idle(self) -> None:
+        if cast("OmegaApp", self.app)._turn_worker is not None:
+            return
+        if self._mention_hits:
+            self._mention_hits = []
+            self._mention_index = 0
+            cast("OmegaApp", self.app)._refresh_status()
+            return
+        self.clear()
+
+    def action_history_or_up(self) -> None:
+        if self._mention_hits:
+            self._mention_index = (self._mention_index - 1) % len(self._mention_hits)
+            cast("OmegaApp", self.app)._refresh_status()
+            return
+        if self.cursor_at_first_line:
+            cast("OmegaApp", self.app).action_history_prev()
+            return
+        self.action_cursor_up()
+
+    def action_history_or_down(self) -> None:
+        if self._mention_hits:
+            self._mention_index = (self._mention_index + 1) % len(self._mention_hits)
+            cast("OmegaApp", self.app)._refresh_status()
+            return
+        if self.cursor_at_last_line:
+            cast("OmegaApp", self.app).action_history_next()
+            return
+        self.action_cursor_down()
+
+    def action_mention_or_tab(self) -> None:
+        if self._try_accept_mention():
+            return
+        self.insert("    ")
+
+    def _cursor_index(self) -> int:
+        row, col = self.cursor_location
+        lines = self.text.split("\n")
+        return sum(len(line) + 1 for line in lines[:row]) + col
+
+    def _move_to_index(self, index: int) -> None:
+        text = self.text
+        index = max(0, min(index, len(text)))
+        row = text.count("\n", 0, index)
+        last_nl = text.rfind("\n", 0, index)
+        col = index if last_nl < 0 else index - last_nl - 1
+        self.move_cursor((row, col))
+
+    def _try_accept_mention(self) -> bool:
+        if not self._mention_hits:
+            return False
+        path = self._mention_hits[self._mention_index]
+        new, cursor = composer_lib.insert_mention(self.text, self._cursor_index(), path)
+        self.text = new
+        self._move_to_index(cursor)
+        self._mention_hits = []
+        self._mention_index = 0
+        cast("OmegaApp", self.app)._refresh_status()
+        return True
+
+    def on_mount(self) -> None:
+        self._sync_box_height()
+
+    def on_text_area_changed(self) -> None:
+        self._refresh_mentions()
+        self._sync_box_height()
+
+    def _content_rows(self) -> int:
+        text = self.text
+        if not text:
+            return 1
+        rows = text.count("\n") + 1
+        width = self.size.width
+        if width <= 1:
+            return rows
+        gutter = 4 if self.show_line_numbers else 0
+        usable = max(1, width - gutter)
+        extra = 0
+        for line in text.split("\n"):
+            if len(line) > usable:
+                extra += (len(line) - 1) // usable
+        return rows + extra
+
+    def _sync_box_height(self) -> None:
+        rows = self._content_rows()
+        # Border (2) + content. Stay one line until the user actually wraps.
+        height = min(self._box_max, max(self._box_min, rows + 2))
+        parent = self.parent
+        if parent is not None:
+            parent.styles.height = height
+        self.show_line_numbers = rows > 1
+
+    def on_selection_changed(self) -> None:
+        self._refresh_mentions()
+
+    def _refresh_mentions(self) -> None:
+        app = cast("OmegaApp", self.app)
+        q = composer_lib.mention_query(self.text, self._cursor_index())
+        if q is None:
+            if self._mention_hits:
+                self._mention_hits = []
+                self._mention_index = 0
+                app._refresh_status()
+            return
+        hits = composer_lib.rank_files(app.workspace_files, q.query)
+        if hits != self._mention_hits:
+            self._mention_hits = hits
+            self._mention_index = 0
+            app._refresh_status()
+
+    def mention_status(self) -> str:
+        if not self._mention_hits:
+            return ""
+        shown = self._mention_hits[:6]
+        i = self._mention_index
+        bits = []
+        for n, path in enumerate(shown):
+            name = path.rsplit("/", 1)[-1]
+            bits.append(f"[{n + 1}] {name}" if n == i else name)
+        extra = f" +{len(self._mention_hits) - 6}" if len(self._mention_hits) > 6 else ""
+        return " @ " + " · ".join(bits) + extra + "  tab/enter"
+
+    async def _on_key(self, event: Key) -> None:
+        # TextArea inserts a newline for Enter before bindings run. Steal it.
+        if event.key == "enter":
+            event.stop()
+            event.prevent_default()
+            self.action_submit()
+            return
+        if event.key in ("shift+enter", "alt+enter"):
+            event.stop()
+            event.prevent_default()
+            self.action_newline()
+            return
+        await super()._on_key(event)
+
+    async def _on_paste(self, event: Paste) -> None:
+        if event.text:
+            event.stop()
+            event.prevent_default()
+            self.insert(event.text)
+            return
+        await super()._on_paste(event)
+
+
+class OmegaApp(App[None]):
+    # Read by `get_css_variables` from inside `App.__init__`, before this
+    # instance has loaded its own preference.
+    theme_choice = theme.DEFAULT
+    CSS = """
+    Screen { layout: vertical; }
+    #body { height: 1fr; }
+    #main { width: 1fr; height: 1fr; }
+    #header { height: 2; }
+    #transcript { height: 1fr; padding-top: 1; }
+    #input-box { height: 3; min-height: 3; max-height: 10; border: round $rule; padding: 0 1; }
+    #input-box:focus-within { border: round $accent; }
+    /* A turn in flight: the bracket stays open and typeable, but its border
+       says so, and enter holds rather than submits. */
+    #input-box.-busy { border: round $warning; }
+    #input-box.-busy:focus-within { border: round $warning; }
+    #mode-tag { width: auto; padding: 0 1 0 0; height: 1; }
+    #prompt { width: 1fr; height: 1fr; background: transparent; border: none; padding: 0; }
+    #prompt.-plan-mode { color: $warning; }
+    #prompt.-discuss-mode { color: $accent; }
+    """
+    BINDINGS = [
+        Binding("ctrl+c", "interrupt", "Cancel turn", show=False, priority=True),
+        Binding("ctrl+d", "quit_app", "Quit", show=False, priority=True),
+        # ctrl+m is not usable here: terminals send the same byte for it as
+        # for Enter, so it would fire the input's submit binding instead.
+        Binding("ctrl+o", "pick_model", "Model", show=False, priority=True),
+        Binding("ctrl+b", "toggle_sidebar", "Sidebar", show=False, priority=True),
+        Binding("shift+tab", "cycle_mode", "Cycle mode", show=False, priority=True),
+        Binding("ctrl+1", "show_tab(0)", "Session", show=False, priority=True),
+        Binding("ctrl+2", "show_tab(1)", "Git", show=False, priority=True),
+        Binding("ctrl+3", "show_tab(2)", "Connections", show=False, priority=True),
+        Binding("[", "cycle_tab(False)", "Prev tab", show=False),
+        Binding("]", "cycle_tab(True)", "Next tab", show=False),
+        Binding("g", "expand_latest", "Expand group", show=False),
+        Binding("G", "jump_end", "Jump to end", show=False),
+    ]
+
+    def __init__(self, cfg: config.Config, sess: session.Session, mode: str,
+                 history: list[dict[str, Any]], model_alias: str | None = None) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.sess = sess
+        self.mode = mode
+        self.history = history
+        self.model_alias = model_alias
+        self._usage: events.Usage | None = None
+        # Cumulative tokens for this session, by model alias (or the raw
+        # model id when no alias applies) -- `/cost` sums these against
+        # `eval.prices`, unlike `_usage` above which only holds the latest event.
+        self._usage_totals: dict[str, dict[str, int]] = {}
+        self._last_model: tuple[str | None, str] | None = None
+        self._held_notice_shown = False
+        self._phase = "idle"
+        self._turn_worker: Worker[None] | None = None
+        self._input_history: InputHistory | None = None
+        self._prefs = prefs.load()
+        self._first_launch = not prefs.PATH.exists()
+        self._sidebar_visible = bool(self._prefs.get("sidebar", False))
+        self.theme_choice = theme.normalize(self._prefs.get("theme"))
+        self.register_theme(theme.SYSTEM_THEME)
+        self.theme = theme.textual_theme(self.theme_choice)
+        self._git_refresh_timer: Timer | None = None
+        self.workspace_files: list[str] = []
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="body"):
+            with Vertical(id="main"):
+                yield HeaderBar(id="header")
+                yield Transcript(id="transcript")
+            yield Sidebar(self.sess, id="sidebar")
+        yield StatusBar(id="status")
+        with Horizontal(id="input-box"):
+            yield Static("", id="mode-tag")
+            yield PromptInput(
+                id="prompt",
+                placeholder="Ask omega…  enter send · shift+enter newline · @ file",
+            )
+
+    def on_mount(self) -> None:
+        # Deferred import: reads the CURRENT `omega.ui.tui.HISTORY`, so tests
+        # that monkeypatch it before construction are respected.
+        from . import HISTORY
+        self._input_history = InputHistory(HISTORY)
+        self._apply_sidebar_visibility()
+        self.query_one(Transcript).set_session(self.sess.id)
+        self._refresh_status()
+        self._apply_mode_style()
+        self._refresh_header()
+        if self.history:
+            self._show_resumed()
+        else:
+            self.query_one(Transcript).show_empty_state()
+        self.set_focus(self.query_one("#prompt", PromptInput))
+        self.run_worker(self._index_workspace, exclusive=False, thread=True)
+
+    def _index_workspace(self) -> None:
+        self.workspace_files = composer_lib.list_workspace_files(self.sess.cwd)
+
+    def on_resize(self, event: Resize) -> None:
+        self._apply_sidebar_visibility()
+        self._refresh_status()
+
+    def get_css_variables(self) -> dict[str, str]:
+        variables = super().get_css_variables()
+        variables["rule"] = theme.rule_color(self.theme_choice)
+        return variables
+
+    def set_theme_choice(self, choice: str) -> None:
+        self.theme_choice = theme.normalize(choice)
+        self.theme = theme.textual_theme(self.theme_choice)
+        self._prefs["theme"] = self.theme_choice
+        prefs.save(self._prefs)
+
+    def _apply_sidebar_visibility(self) -> None:
+        """The panel follows the user's own ctrl+b/`/sidebar` preference, but
+        never below `_MIN_WIDTH_FOR_SIDEBAR` total columns -- squeezed into
+        whatever's left of a narrow terminal it stops being readable rather
+        than useful, so it auto-hides there instead (`StatusBar` surfaces a
+        dim hint explaining why, via `_sidebar_auto_hidden`)."""
+        self.query_one(Sidebar).display = self._sidebar_visible and self._sidebar_fits()
+
+    def _sidebar_fits(self) -> bool:
+        return self.size.width >= _MIN_WIDTH_FOR_SIDEBAR
+
+    def _sidebar_auto_hidden(self) -> bool:
+        return self._sidebar_visible and not self._sidebar_fits()
+
+    def _show_resumed(self) -> None:
+        hist = self.history
+        if hist and str(hist[-1].get("content", "")).startswith(session.RESUME_PREFIX):
+            hist = hist[:-1]
+        turns = sum(1 for m in hist if m.get("role") == "user")
+        ago = format.relative_age(time.time() - self.sess.updated) if self.sess.updated else ""
+        self.query_one(Transcript).add_resumed(self.sess.id, turns, len(hist), self.sess.cwd, ago)
+
+    def _refresh_header(self, *, force: bool = False) -> None:
+        self.run_worker(self._load_header(force=force), exclusive=False, thread=False)
+
+    async def _load_header(self, *, force: bool) -> None:
+        cwd = self.sess.cwd
+        branch = None if force else _branch_cache.get(cwd)
+        if branch is None:
+            branch = await _lookup_branch(cwd)
+            _branch_cache[cwd] = branch
+        self.query_one(HeaderBar).set_state(cwd, branch, self.sess.id)
+
+    def _role_name(self) -> str:
+        return _MODE_ROLE.get(self.mode, "main")
+
+    def _apply_mode_style(self) -> None:
+        prompt = self.query_one("#prompt", PromptInput)
+        prompt.set_class(self.mode == "plan", "-plan-mode")
+        prompt.set_class(self.mode == "discuss", "-discuss-mode")
+        style = _MODE_TAG_STYLE.get(self.mode, "dim")
+        self.query_one("#mode-tag", Static).update(f"[{style}]{self.mode}[/{style}] [bold]›[/bold]")
+
+    def _refresh_status(self) -> None:
+        role_name = self._role_name()
+        alias, model = self._last_model or (None, "?")
+        if self._last_model is None:
+            # Before the first ModelUsed event of the session, fall back to a
+            # static lookup so the status bar isn't blank on first render.
+            try:
+                role = self.cfg.model(self.model_alias) if self.model_alias else self.cfg.role(role_name)
+                alias, model = role.alias, str(role.model)
+            except Exception:
+                alias, model = self.model_alias, "?"
+            self.query_one(Sidebar).session_tab.record_model(alias, model, limit=self._static_context_limit())
+        turns = sum(1 for m in self.history if m.get("role") == "user")
+        note = ""
+        try:
+            note = self.query_one("#prompt", PromptInput).mention_status()
+        except Exception:
+            note = ""
+        state = StatusState(mode=self.mode, role_name=role_name, model=model, alias=alias,
+                            session_id=self.sess.id, turns=turns, usage=self._usage,
+                            phase=self._phase, sidebar_auto_hidden=self._sidebar_auto_hidden(),
+                            note=note)
+        self.query_one(StatusBar).set_state(state)
+
+    def _static_context_limit(self) -> int:
+        try:
+            return self._context_limit()
+        except Exception:
+            return 0
+
+    def _schedule_git_refresh(self) -> None:
+        if self._git_refresh_timer is not None:
+            self._git_refresh_timer.stop()
+        self._git_refresh_timer = self.set_timer(0.3, self._run_git_refresh)
+
+    def _run_git_refresh(self) -> None:
+        self._git_refresh_timer = None
+        self.query_one(Sidebar).git_tab.refresh_repos()
+
+    def emit(self, ev: events.Event) -> None:
+        trace.append(self.sess.id, ev, self.sess.turns)
+        # A rendering bug (an unescaped model string reaching rich's markup
+        # parser, say) must never abort the turn the model is mid-way through
+        # -- show one dim marker and keep going instead of propagating. The
+        # inner try/except is deliberate: even the marker line's own render
+        # must not be able to re-raise and kill the turn a second time.
+        try:
+            self._dispatch(ev)
+        except Exception as e:
+            # `add_dim` escapes its own text, so pass the raw message through --
+            # escaping it here too would double-escape.
+            try:
+                self.query_one(Transcript).add_dim(
+                    f"⚠ render error: {type(e).__name__}: {str(e)[:120]}")
+            except Exception:
+                pass
+
+    def _dispatch(self, ev: events.Event) -> None:
+        transcript = self.query_one(Transcript)
+        sidebar = self.query_one(Sidebar)
+        match ev:
+            case events.Phase(state=state):
+                self._phase = state
+                transcript.note_phase(state)
+                sidebar.session_tab.note_phase(state)
+                self._refresh_status()
+            case events.TextDelta(text=text):
+                transcript.add_text_delta(text)
+            case events.ToolStart():
+                transcript.add_tool_start(ev)
+                sidebar.session_tab.record_tool_start(ev)
+                if ev.name in ("find_tools", "call_tool"):
+                    sidebar.connections_tab.refresh_status()
+            case events.ToolEnd():
+                transcript.add_tool_end(ev)
+                sidebar.session_tab.record_tool_end(ev)
+                if ev.name in ("write", "edit", "bash"):
+                    self._schedule_git_refresh()
+                if ev.name in ("find_tools", "call_tool"):
+                    sidebar.connections_tab.refresh_status()
+            case events.SubagentSpawned():
+                transcript.add_subagent_spawned(ev)
+                sidebar.session_tab.record_subagent_spawned(ev)
+            case events.SubagentDone():
+                transcript.add_subagent_done(ev)
+                sidebar.session_tab.record_subagent_done(ev)
+            case events.Compacted(note=note):
+                transcript.add_compacted(ev)
+                if not note.startswith("compaction skipped"):
+                    self.sess.compactions += 1
+            case events.MemoryWrite():
+                transcript.add_memory_write(ev)
+            case events.MemoryConsolidated():
+                transcript.add_memory_consolidated(ev)
+            case events.Error():
+                transcript.add_error(ev)
+            case events.Usage():
+                self._usage = ev
+                self._accumulate_usage(ev)
+                sidebar.session_tab.record_usage(ev)
+                transcript.note_usage(ev)
+                self._refresh_status()
+            case events.ModelUsed(alias=alias, model=model):
+                self._last_model = (alias, model)
+                sidebar.session_tab.record_model(alias, model)
+                self._refresh_status()
+            case events.Done(text=text):
+                transcript.finalize_turn(text)
+        if _Checkpoint is not None and isinstance(ev, _Checkpoint):
+            transcript.add_checkpoint(ev)
+        elif _Verified is not None and isinstance(ev, _Verified):
+            transcript.add_verified(ev)
+        elif _JobStarted is not None and isinstance(ev, _JobStarted):
+            transcript.add_job_started(ev)
+        elif _JobFinished is not None and isinstance(ev, _JobFinished):
+            transcript.add_job_finished(ev)
+
+    def _accumulate_usage(self, ev: events.Usage) -> None:
+        alias = (self._last_model[0] or self._last_model[1]) if self._last_model else "?"
+        totals = self._usage_totals.setdefault(
+            alias, {"prompt": 0, "completion": 0, "cache_read": 0, "cache_write": 0})
+        totals["prompt"] += ev.prompt_tokens
+        totals["completion"] += ev.completion_tokens
+        totals["cache_read"] += ev.cache_read
+        totals["cache_write"] += ev.cache_write
+
+    def _cost_text(self) -> str:
+        if not self._usage_totals:
+            return "no usage yet this session"
+        from ...eval import prices
+
+        lines = []
+        grand_total = 0.0
+        any_unpriced = False
+        for alias, t in sorted(self._usage_totals.items()):
+            cost = prices.estimate_cost(alias, t["prompt"], t["completion"])
+            if cost is None:
+                any_unpriced = True
+                cost_text = "unknown"
+            else:
+                grand_total += cost
+                cost_text = f"${cost:.4f}"
+            lines.append(f"{alias}: {t['prompt']} in / {t['completion']} out "
+                        f"(cache {t['cache_read']} read / {t['cache_write']} write) · {cost_text}")
+        if len(self._usage_totals) > 1:
+            suffix = " + unpriced models" if any_unpriced else ""
+            lines.append(f"total: ${grand_total:.4f}{suffix}")
+        return "\n".join(lines)
+
+    def _submit_prompt(self) -> None:
+        prompt = self.query_one("#prompt", PromptInput)
+        # Mid-turn, enter is a no-op that KEEPS what was typed. The widget
+        # used to be disabled outright for the length of a turn, which meant
+        # a thought had to be held in the reader's head until the turn ended.
+        # Leaving it live lets that thought be written down where it belongs;
+        # refusing the submit (rather than queueing or interrupting) keeps the
+        # running turn the only thing in flight, so nothing is sent that the
+        # turn's own output might have made wrong.
+        if self._turn_worker is not None:
+            # Once per turn, not once per keypress -- enter pressed five times
+            # while waiting should not push five identical notices into the
+            # transcript the reader is trying to follow.
+            if not self._held_notice_shown:
+                self._held_notice_shown = True
+                self.query_one(Transcript).add_dim(
+                    "still working — your prompt is held; ctrl+c cancels the turn")
+            return
+        text = prompt.value.strip()
+        prompt.value = ""
+        if not text:
+            return
+        if self._input_history is not None:
+            self._input_history.append(text)
+        if text == "?" or text.startswith("/"):
+            self._handle_command(text)
+        else:
+            self._start_turn(text)
+
+    def _unknown_command(self, text: str) -> str:
+        word = text.split()[0] if text.split() else text
+        match = difflib.get_close_matches(word, _COMMANDS, n=1)
+        suggestion = f" — did you mean {match[0]}?" if match else ""
+        return f"unknown command: {text}{suggestion}"
+
+    def _handle_command(self, text: str) -> None:
+        transcript = self.query_one(Transcript)
+        if text in ("/plan", "/build", "/discuss"):
+            new_mode = text[1:]
+            if new_mode == "discuss" and "discuss" not in loop.MODES:
+                transcript.add_dim("discuss mode not available in this build")
+                return
+            self.mode = new_mode
+            transcript.add_mode_switch(self.mode)
+            self._apply_mode_style()
+            self._refresh_status()
+        elif text == "/mode":
+            transcript.add_dim(f"mode: {self.mode}")
+        elif text == "/memory-gc":
+            self.run_worker(self._memory_gc(), exclusive=False, thread=False)
+        elif text == "/model":
+            self.run_worker(self._pick_model(), exclusive=False, thread=False)
+        elif text.startswith("/model "):
+            self._set_model(text[len("/model "):].strip())
+        elif text == "/sidebar":
+            self.action_toggle_sidebar()
+        elif text == "/theme":
+            transcript.add_dim(f"theme: {self.theme_choice}  ({' · '.join(theme.CHOICES)})")
+        elif text.startswith("/theme "):
+            choice = text[len("/theme "):].strip()
+            if choice not in theme.CHOICES:
+                transcript.add_dim(f"unknown theme: {choice}  (want one of {', '.join(theme.CHOICES)})")
+                return
+            self.set_theme_choice(choice)
+            transcript.add_dim(f"theme: {choice}")
+        elif text == "/cost":
+            transcript.add_dim(self._cost_text())
+        elif text == "/export" or text.startswith("/export "):
+            path = text[len("/export"):].strip() or None
+            out = export.write(self.history, self.sess.id, path)
+            transcript.add_dim(f"exported to {out}")
+        elif text == "/compact":
+            self.run_worker(self._force_compact(), exclusive=False, thread=False)
+        elif text == "/undo" or text.startswith("/undo "):
+            arg = text[len("/undo"):].strip()
+            steps = int(arg) if arg.isdigit() else 1
+            self.run_worker(self._undo(steps), exclusive=False, thread=False)
+        elif text == "/diff":
+            self.run_worker(self._diff(), exclusive=False, thread=False)
+        elif text == "/verify":
+            self.run_worker(self._verify(), exclusive=False, thread=False)
+        elif text == "/sessions":
+            self.run_worker(self._pick_session(), exclusive=False, thread=False)
+        elif text in ("/help", "?"):
+            transcript.add_dim(_HELP_TEXT)
+        elif text == "/quit":
+            self.action_quit_app()
+        else:
+            transcript.add_dim(self._unknown_command(text))
+
+    async def _memory_gc(self) -> None:
+        transcript = self.query_one(Transcript)
+        transcript.add_dim(await consolidate.run(self.cfg, "project", force=True))
+        transcript.add_dim(await consolidate.run(self.cfg, "global", force=True))
+
+    def _context_limit(self) -> int:
+        role = self.cfg.model(self.model_alias) if self.model_alias else self.cfg.role(self._role_name())
+        return role.context
+
+    async def _force_compact(self) -> None:
+        transcript = self.query_one(Transcript)
+        limit = self._context_limit()
+        note = await compact.maybe_compact(self.cfg, self.history, used=limit, limit=limit)
+        transcript.add_dim(note or "nothing to compact")
+
+    async def _undo(self, steps: int) -> None:
+        transcript = self.query_one(Transcript)
+        try:
+            from ... import checkpoint
+        except ImportError:
+            transcript.add_dim("not available in this build")
+            return
+        plural = "" if steps == 1 else "s"
+        confirmed = await self.push_screen_wait(
+            ConfirmScreen("undo", {}, f"revert the last {steps} turn{plural}?"))
+        if not confirmed:
+            transcript.add_dim("undo cancelled")
+            return
+        note = await asyncio.to_thread(checkpoint.undo, self.sess.id, steps, cwd=self.sess.cwd)
+        transcript.add_dim(note)
+
+    async def _diff(self) -> None:
+        transcript = self.query_one(Transcript)
+        try:
+            from ... import checkpoint
+        except ImportError:
+            transcript.add_dim("not available in this build")
+            return
+        text = await asyncio.to_thread(checkpoint.diff, self.sess.id, cwd=self.sess.cwd)
+        await self.push_screen_wait(DiffScreen(None, "checkpoint diff", diff_text=text))
+
+    async def _verify(self) -> None:
+        transcript = self.query_one(Transcript)
+        try:
+            from ... import verify
+        except ImportError:
+            transcript.add_dim("not available in this build")
+            return
+        checks = await asyncio.to_thread(verify.detect, self.sess.cwd)
+        if not checks:
+            transcript.add_dim("no checks detected for this project")
+            return
+        results = await asyncio.to_thread(verify.run, checks, self.sess.cwd)
+        ok = all(r.ok for r in results)
+        summary = ", ".join(f"{r.check.name} {'✓' if r.ok else '✗'}" for r in results)
+        transcript.add_dim(("✓ verified: " if ok else "✗ verification failed: ") + summary)
+
+    async def _pick_session(self) -> None:
+        transcript = self.query_one(Transcript)
+        rows = [s for s in session.all_sessions() if s.cwd == self.sess.cwd and s.id != self.sess.id][:20]
+        if not rows:
+            transcript.add_dim("no other sessions for this directory")
+            return
+        chosen = await self.push_screen_wait(SessionsScreen(rows))
+        if chosen:
+            self._resume_session(chosen)
+
+    def _resume_session(self, sid: str) -> None:
+        new_sess = session.load(sid)
+        self.sess = new_sess
+        self.mode = new_sess.mode
+        self.history.clear()
+        self.history.extend(new_sess.history)
+        self.model_alias = new_sess.model_override
+        self._usage = None
+        self._usage_totals = {}
+        self._last_model = None
+        transcript = self.query_one(Transcript)
+        transcript.set_session(new_sess.id)
+        turns = sum(1 for m in self.history if m.get("role") == "user")
+        ago = format.relative_age(time.time() - new_sess.updated) if new_sess.updated else ""
+        transcript.add_resumed(new_sess.id, turns, len(self.history), new_sess.cwd, ago)
+        self.query_one(Sidebar).session_tab.set_session(new_sess)
+        self._apply_mode_style()
+        self._refresh_status()
+        self._refresh_header(force=True)
+
+    async def _pick_model(self) -> None:
+        alias = await self.push_screen_wait(ModelPickerScreen(self.cfg.models, self.model_alias))
+        if alias:
+            self._set_model(alias)
+
+    def _set_model(self, arg: str) -> None:
+        try:
+            alias = self.cfg.resolve_alias(arg)
+        except SystemExit as e:
+            self.query_one(Transcript).add_dim(str(e))
+            return
+        self.model_alias = alias
+        self.sess.model_override = alias
+        role = self.cfg.model(alias)
+        self._last_model = (alias, role.model)
+        # The stale token/limit pairing belongs to the model being replaced --
+        # showing it against the new model's name would misreport its context
+        # window until the next Usage event (which may be rounds away).
+        self._usage = None
+        self.query_one(Transcript).add_dim(f"model: {alias} · {role.model}")
+        self._refresh_status()
+
+    def action_pick_model(self) -> None:
+        self.run_worker(self._pick_model(), exclusive=False, thread=False)
+
+    def action_cycle_mode(self) -> None:
+        # A priority binding fires regardless of focus, including inside a
+        # modal -- restore its own shift+tab (focus_previous, Screen's
+        # default) there instead of silently swallowing the key.
+        if isinstance(self.screen, ModalScreen):
+            self.screen.focus_previous()
+            return
+        available = [m for m in _MODE_CYCLE if m != "discuss" or "discuss" in loop.MODES]
+        idx = available.index(self.mode) if self.mode in available else -1
+        self.mode = available[(idx + 1) % len(available)]
+        self.query_one(Transcript).add_mode_switch(self.mode)
+        self._apply_mode_style()
+        self._refresh_status()
+
+    def action_toggle_sidebar(self) -> None:
+        self._sidebar_visible = not self._sidebar_visible
+        self._apply_sidebar_visibility()
+        self._prefs["sidebar"] = self._sidebar_visible
+        prefs.save(self._prefs)
+        self._refresh_status()
+
+    def action_show_tab(self, index: int) -> None:
+        self.query_one(Sidebar).show_tab(index)
+
+    def action_cycle_tab(self, forward: bool) -> None:
+        self.query_one(Sidebar).cycle_tab(forward)
+
+    def action_expand_latest(self) -> None:
+        self.query_one(Transcript).expand_latest()
+
+    def action_jump_end(self) -> None:
+        self.query_one(Transcript).jump_to_end()
+
+    def _start_turn(self, text: str) -> None:
+        self.history.append({"role": "user", "content": text})
+        self.query_one(Transcript).add_user_message(text, self.mode)
+        self.query_one(Sidebar).session_tab.reset_turn()
+        self.query_one("#input-box").add_class("-busy")
+        self._held_notice_shown = False
+        self._turn_worker = self.run_worker(self._run_turn(), exclusive=True, thread=False)
+
+    async def _run_turn(self) -> None:
+        interrupted = False
+        try:
+            await loop.run_turn(self.cfg, self.history, mode=self.mode, emit=self.emit,
+                                model=self.model_alias)
+        except asyncio.CancelledError:
+            interrupted = True
+        except Exception as e:
+            self.emit(events.Error(message=f"{type(e).__name__}: {e}"))
+        finally:
+            try:
+                self.sess.close_turn(self.history, self.mode, interrupted)
+            except Exception as e:
+                self.query_one(Transcript).add_error(events.Error(f"could not save session: {e}"))
+            self._turn_worker = None
+            self.emit(events.Phase("idle"))
+            if self._git_refresh_timer is not None:
+                self._git_refresh_timer.stop()
+                self._git_refresh_timer = None
+            sidebar = self.query_one(Sidebar)
+            sidebar.git_tab.refresh_repos()
+            sidebar.connections_tab.refresh_status()
+            self._refresh_header(force=True)
+            self.query_one("#input-box").remove_class("-busy")
+            self.set_focus(self.query_one("#prompt", PromptInput))
+
+    def action_interrupt(self) -> None:
+        if self._turn_worker is not None:
+            self._turn_worker.cancel()
+
+    def action_quit_app(self) -> None:
+        prompt = self.query_one("#prompt", PromptInput)
+        if prompt.value:
+            prompt.action_delete_right()
+            return
+        if self._turn_worker is not None:
+            self._turn_worker.cancel()
+        self.exit()
+
+    def action_history_prev(self) -> None:
+        self._cycle_history(forward=False)
+
+    def action_history_next(self) -> None:
+        self._cycle_history(forward=True)
+
+    def _cycle_history(self, forward: bool) -> None:
+        if self._input_history is None:
+            return
+        prompt = self.query_one("#prompt", PromptInput)
+        value = (self._input_history.next(prompt.value) if forward
+                 else self._input_history.prev(prompt.value))
+        if value is not None:
+            prompt.value = value
+            prompt.action_end()
+
+    async def confirm(self, name: str, args: dict[str, Any], why: str) -> bool:
+        return await self.push_screen_wait(ConfirmScreen(name, args, why))
+
+    async def ask_user(self, question: str, options: list[events.Option], multi_select: bool) -> str:
+        return await self.push_screen_wait(AskUserScreen(question, options, multi_select))