induscode 0.1.0__py3-none-any.whl

induscode/console/app.py

@@ -0,0 +1,1677 @@
+"""ConsoleApp — the top-level Textual application for the interactive console.
+
+Rewrite of TS ``src/console/components/TerminalConsole.tsx`` (1089 LOC) as a
+:class:`textual.app.App`, modeled on the framework's ``ui_bridge.app``
+``InteractiveApp`` (the working reference for the signal→snapshot projection,
+the ``post_message`` relay, the worker patterns, the Esc abort, the exit
+codes, and the exit transcript). This is the surface the host process renders
+to drive a session from a live terminal: it owns one
+:func:`~induscode.console.reducer.console_reducer` store, subscribes to the
+conductor's :data:`~induscode.conductor.SessionSignal` stream and projects
+each signal into reducer events plus retained-widget updates, renders the
+console chrome (:class:`~induscode.console.components.Banner`,
+:class:`~induscode.console.components.StatusBar`) around the framework
+widgets (``MessageList`` / ``StreamingMarkdown`` / ``TaskPanel`` /
+``PromptEditor``), and derives its ``BINDINGS`` from the pure
+:data:`~induscode.console.input.INTENT_TABLE`.
+
+The app stays deliberately thin: every *decision* lives in a pure module (the
+reducer, the intent table, the chord/exit-window machines, the slash
+resolver, the completion providers, the overlay flows). The app holds only
+the live values those pure functions need carried between keystrokes — the
+chord latch, the Ctrl+C exit window, the streaming segments — plus the
+timers, and it wires events in and pushes state out.
+
+Port deltas, all locked by the plan (analysis 02 §7 + risks 2–5):
+
+- **Streaming-row bookkeeping is REDESIGNED, not copied** (risk 2). The TS
+  surface kept a ``liveAnswer``/``answerText`` ref pair per kind with a
+  documented first-delta-clipping bug history, and double-rendered streams
+  (reducer rows *plus* the MessageList re-reading ``conductor.messages()``).
+  Here each streaming kind is one :class:`_LiveSegment` value (row id +
+  accumulated text + the retained ``StreamingMarkdown`` widget): a delta with
+  no open segment mints a fresh row and widget; a delta with one appends to
+  both; ``tool_start`` *settles* the segment (the next answer text starts a
+  fresh row — the TS run-on/clipping bug class is structurally impossible);
+  ``turn_end``/``fault`` settle and clear the live tail, after which the
+  ``MessageList`` (fed from ``conductor.messages()``) is the sole renderer of
+  the settled turn. The reducer rows remain the *bookkeeping ledger* exactly
+  as in TS (where they were never rendered either — the TS render path was
+  MessageList + StreamingMarkdown too) and :meth:`ConsoleApp.stream_parity_report`
+  is the parity check the plan asks for: the ledger rows must match what the
+  retained widgets were fed.
+- **The editor collapses into the framework.** The TS hand-rolled composer
+  (buffer/caret splice, software caret, paste vault, burst debounce,
+  bracketed-paste stripping) is the framework ``PromptEditor``/``EditorCore``;
+  the console contributes only the autocomplete provider, the submit routing,
+  and the app-level chords. The paste-burst machinery and the bracketed-paste
+  regex are deleted (Textual delivers one assembled ``events.Paste``).
+- **Viewport math is deleted.** ``transcriptHeight`` / terminal-resize
+  tracking / the ``pulse()`` re-render hack die: the ``MessageList`` is a
+  ``VerticalScroll`` that owns its viewport, and retained widgets re-render
+  from pushed state.
+- **OSC 2 terminal title goes through Textual** (risk 4): the app sets
+  ``self.title`` (Textual's driver owns the escape writes); no raw escape
+  bytes are emitted, so a redirected run can never leak control sequences.
+- **Chord-latch scope** (documented divergence): TS broke a primed double-tap
+  latch on *any* key. Here printable keys are consumed by the editor and
+  never reach the app, so the latch is bounded by the
+  :data:`~induscode.console.input.CHORD_WINDOW_MS` expiry timer instead. The
+  fired outcomes and the window width are identical.
+- **Overlays are awaited flows** (risk 1): an ``overlay:open`` intent (or a
+  slash handler's ``open_modal``) dispatches ``modal:open``, runs
+  :func:`~induscode.console.overlays.open_overlay` in a worker
+  (``push_screen_wait`` demands one), folds the returned
+  ``OverlayOutcome.events`` through the reducer, and dispatches
+  ``modal:close`` — so ``ConsoleState.modal`` mirrors the screen stack.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import time
+from collections.abc import Mapping
+from dataclasses import dataclass, replace
+from typing import Any, Callable, ClassVar, Final, Literal, Sequence
+
+from rich.text import Text
+from textual.app import App, ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Vertical, VerticalScroll
+from textual.message import Message
+from textual.timer import Timer
+from textual.widgets import Static
+
+from indusagi.react_ink import (
+    ContextUsage,
+    MessageList,
+    PendingMessageItem,
+    SessionSnapshot,
+    SessionStats,
+    SessionTokenStats,
+    StatusMessage,
+    StreamingMarkdown,
+    TaskPanel,
+    ToolExecutionState,
+    theme_variable_defaults,
+)
+from indusagi.react_ink.components.editor import PromptEditor
+from indusagi.react_ink.utils.message_groups import (
+    extract_tool_text,
+    preview_text,
+    safe_stringify,
+)
+from indusagi.ui_bridge.app import exit_transcript_text
+
+from induscode.console_slash import SlashContext, SlashRegistry, resolve_slash
+from induscode.kit import open_in_external_editor, read_clipboard_image
+from induscode.workspace.brand import VERSION
+
+from .components import Banner, StatusBar
+from .contract import (
+    MODAL_KINDS,
+    BlockAppend,
+    BusySet,
+    ConsoleEvent,
+    ConsoleState,
+    ConsoleTheme,
+    ModalClose,
+    ModalKind,
+    ModalOpen,
+    OverlayServices,
+    RowsAppend,
+    RowsPatch,
+    SessionConductor,
+    SessionSignal,
+    StatusSet,
+    Tick,
+    ToggleReasoning,
+    ViewRow,
+)
+from .input import (
+    CHORD_WINDOW_MS,
+    INTENT_TABLE,
+    NO_CHORD,
+    NO_EXIT_WINDOW,
+    ChordLatch,
+    ConsoleAutocompleteProvider,
+    ConsoleIntent,
+    ExitWindow,
+    advance_chord,
+    advance_exit_window,
+    create_dir_reader,
+)
+from .overlays import open_overlay
+from .reducer import console_reducer, init_console_state
+from .startup import StartupInputs, StartupMap, gather_startup
+from .theme import resolve_theme
+
+__all__ = [
+    "ConductorSignalMessage",
+    "ConsoleApp",
+    "FALLBACK_CONTEXT_WINDOW",
+    "TOOL_CARD_PREVIEW_LINES",
+    "TRANSCRIPT_MAX_ITEMS",
+    "count_providers",
+    "fresh_row_id",
+    "project_snapshot",
+    "read_branch",
+    "read_double_escape_action",
+    "summarize_tool_args",
+    "tool_card_text",
+]
+
+
+# ---------------------------------------------------------------------------
+# Tunables
+# ---------------------------------------------------------------------------
+
+#: The context-window size assumed when a model exposes none of its own
+#: (TS ``FALLBACK_CONTEXT_WINDOW``).
+FALLBACK_CONTEXT_WINDOW: Final[int] = 200_000
+
+#: The retained transcript window. The TS viewport math (``transcriptHeight``
+#: over the live terminal row count) is deleted — the ``MessageList`` is a
+#: scrollable retained log — so this is simply a prune cap on mounted rows.
+TRANSCRIPT_MAX_ITEMS: Final[int] = 240
+
+#: The window/tab title shown when the session carries no name.
+_DEFAULT_TITLE: Final[str] = "indus console"
+
+#: How many completion candidates the suggestion overlay lists at once.
+_SUGGESTION_WINDOW: Final[int] = 8
+
+#: How many result lines a collapsed tool card paints before deferring the
+#: rest behind the ``… (+N lines, ctrl+o to expand)`` tail. This is the TS
+#: tool-card collapsed budget (``ToolEventBlock`` / ``MessageList`` clamp
+#: ``maxContentLines={10}``), so the live card and the settled transcript
+#: card show the same preview window.
+TOOL_CARD_PREVIEW_LINES: Final[int] = 10
+
+
+# ---------------------------------------------------------------------------
+# Pure helpers (ported from the TS module-level functions)
+# ---------------------------------------------------------------------------
+
+
+def read_branch(cwd: str | None = None) -> str | None:
+    """Read the current VCS branch once, returning ``None`` outside a repo.
+
+    Port of the TS ``readBranch``: shells out to
+    ``git rev-parse --abbrev-ref HEAD`` and trims the result; any failure
+    (no git, detached, not a repo) collapses to ``None`` so the footer simply
+    omits the branch segment rather than throwing.
+
+    :param cwd: the directory to probe (defaults to the process cwd)
+    """
+    try:
+        out = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=cwd if cwd is not None else os.getcwd(),
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if out.returncode != 0:
+        return None
+    branch = out.stdout.strip()
+    return branch if len(branch) > 0 else None
+
+
+def count_providers(conductor: SessionConductor) -> int:
+    """Count the distinct provider ids among the catalog the picker would
+    list (TS ``countProviders``)."""
+    seen: set[str] = set()
+    try:
+        for card in conductor.available_models():
+            seen.add(card.provider)
+    except Exception:
+        return 0
+    return len(seen)
+
+
+def read_double_escape_action(
+    services: OverlayServices | None,
+) -> Literal["tree", "fork", "clear"]:
+    """Resolve what a double-Escape should do from the preference store,
+    normalised to one of the three surface behaviours.
+
+    Port of the TS ``readDoubleEscapeAction``: reads ``doubleEscapeAction``;
+    the legacy ``branch`` / ``rewind`` values map onto the tree / fork
+    behaviours respectively. Any read fault, a missing services bundle, or an
+    unrecognised value collapses to ``clear`` so the chord always has a
+    defined effect.
+    """
+    if services is None:
+        return "clear"
+    try:
+        raw = services.settings.get("doubleEscapeAction")
+    except Exception:
+        return "clear"
+    if raw in ("tree", "branch"):
+        return "tree"
+    if raw in ("fork", "rewind"):
+        return "fork"
+    return "clear"
+
+
+#: Memoized "model id -> real context window" cache for the by-id fallback
+#: resolver. The full framework catalog (~840 models) is a stable, process-wide
+#: table, so a window once resolved for an id never changes; caching it keeps
+#: ``project_snapshot`` (called on every refresh) from re-walking the catalog.
+_CONTEXT_WINDOW_BY_ID: dict[str, int] = {}
+
+
+def _context_window_by_id(model_id: str) -> int:
+    """Resolve a model's REAL context window from the framework full catalog
+    by bare model id, returning ``0`` when no catalog entry matches.
+
+    This is the by-id safety net for :func:`_resolve_context_window`: the bound
+    model object already carries ``contextWindow`` on the live path (the
+    matcher binds ``card.model``), but a model object assembled some other way
+    (a stub, a partial record) may omit it. Rather than collapse such a model
+    onto :data:`FALLBACK_CONTEXT_WINDOW`, we look its window up by id across the
+    FULL catalog — the same ``get_card`` the gateway uses — so a real catalog
+    model is never reported against the wrong denominator. A genuinely unknown
+    id misses here (``0``) and only then falls through to the fallback.
+    """
+    if not model_id:
+        return 0
+    cached = _CONTEXT_WINDOW_BY_ID.get(model_id)
+    if cached is not None:
+        return cached
+    window = 0
+    try:
+        from indusagi.llmgateway.catalog import get_card
+
+        card = get_card(model_id)
+        if card is not None:
+            raw = getattr(card, "context_window", None)
+            if raw is None:
+                raw = getattr(card, "contextWindow", None)
+            if isinstance(raw, int) and raw > 0:
+                window = raw
+    except Exception:
+        # The catalog is optional infrastructure; any failure to consult it
+        # simply leaves the by-id net empty and lets the caller fall back.
+        window = 0
+    _CONTEXT_WINDOW_BY_ID[model_id] = window
+    return window
+
+
+def _resolve_context_window(model: Any, model_id: str) -> int:
+    """Resolve the context-window denominator for ``ctx:%``.
+
+    Mirrors the TS ``projectSnapshot`` rule (``model.contextWindow > 0 ?
+    model.contextWindow : FALLBACK``) but adds a by-id catalog net BEFORE the
+    literal fallback so a real catalog model whose bound object happens to lack
+    a positive window still reports its true denominator:
+
+    1. the bound model's own ``contextWindow`` (the live path — already correct
+       for every catalog model, since the matcher binds the full ``card.model``);
+    2. a by-id lookup over the FULL framework catalog (covers the ~840-model
+       fallback catalog, not just the curated cards);
+    3. :data:`FALLBACK_CONTEXT_WINDOW`, hit only for a genuinely unknown id.
+    """
+    raw_window = getattr(model, "contextWindow", 0) if model is not None else 0
+    if isinstance(raw_window, int) and raw_window > 0:
+        return raw_window
+    by_id = _context_window_by_id(model_id)
+    if by_id > 0:
+        return by_id
+    return FALLBACK_CONTEXT_WINDOW
+
+
+def project_snapshot(
+    conductor: SessionConductor,
+    services: OverlayServices | None,
+    messages: Sequence[Any],
+    cwd: str,
+) -> SessionSnapshot:
+    """Project the conductor's :class:`~induscode.conductor.ConductorState`
+    plus the console's runtime handles into the framework
+    :class:`~indusagi.react_ink.SessionSnapshot` the Footer / StatusLine /
+    TaskPanel strips read.
+
+    Port of the TS ``projectSnapshot`` as a pure function. The console stores
+    no session data of its own, so the snapshot is assembled per refresh from
+    the live conductor snapshot (model id, usage, phase) and the runtime
+    reads (stats, pending count, the auto-compact preference). Context
+    occupancy is the LATEST turn's footprint (``snap.contextTokens``), not
+    the cumulative session spend — summing input across every turn would
+    inflate ``ctx:%`` far past the real window usage.
+    """
+    snap = conductor.snapshot()
+    model = conductor.model()
+    # The denominator is the model's REAL context window: the bound model's own
+    # ``contextWindow`` (correct for every catalog model on the live path),
+    # else a by-id lookup over the full framework catalog, else the fallback —
+    # so haiku reads 200k, opus-4-8 1M, gpt-5.x its own window, never a wrong
+    # fixed denominator. ``model.id`` is preferred over ``snap.modelId`` because
+    # the latter is the canonical "provider/modelId" key while the catalog is
+    # keyed by bare id; both are tried so either spelling resolves.
+    model_id = ""
+    if model is not None:
+        model_id = getattr(model, "id", "") or ""
+    context_window = _resolve_context_window(model, model_id)
+    used_tokens = snap.contextTokens
+    percent = (used_tokens / context_window) * 100 if context_window > 0 else 0.0
+    stats = conductor.stats()
+    pending = conductor.pending_count()
+    # The footer "(auto)" marker mirrors the real auto-compact preference; an
+    # absent services bundle (headless / test) keeps the default-on behaviour.
+    auto_compact = True
+    if services is not None:
+        try:
+            auto_compact = bool(services.settings.get("autoCompact"))
+        except Exception:
+            auto_compact = True
+    return SessionSnapshot(
+        messages=tuple(messages),
+        model=model,
+        thinkingLevel=conductor.thinking_level(),
+        isStreaming=snap.phase == "streaming",
+        isCompacting=snap.phase == "condensing",
+        isBashRunning=snap.phase == "tooling",
+        pendingMessageCount=pending,
+        pendingToolCallCount=0,
+        sessionId=snap.head.sessionId,
+        sessionFile=None,
+        sessionName=conductor.session_name(),
+        cwd=cwd,
+        autoCompactEnabled=auto_compact,
+        leafId=snap.head.leaf,
+        stats=SessionStats(
+            sessionId=stats.sessionId,
+            userMessages=stats.userMessages,
+            assistantMessages=stats.assistantMessages,
+            toolCalls=stats.toolCalls,
+            toolResults=stats.toolResults,
+            totalMessages=stats.totalMessages,
+            tokens=SessionTokenStats(
+                input=stats.tokens.input,
+                output=stats.tokens.output,
+                cacheRead=stats.tokens.cacheRead,
+                cacheWrite=stats.tokens.cacheWrite,
+                total=stats.tokens.total,
+            ),
+            cost=stats.cost,
+        ),
+        contextUsage=ContextUsage(
+            tokens=used_tokens,
+            contextWindow=context_window,
+            percent=percent,
+        ),
+    )
+
+
+_ROW_SEED_ALPHABET: Final[str] = "0123456789abcdefghijklmnopqrstuvwxyz"
+
+
+def fresh_row_id(seed: int) -> str:
+    """Mint a unique row id for a freshly opened transcript row (the TS
+    ``freshRowId``: a base-36 seed plus a random suffix)."""
+    digits = ""
+    value = seed
+    while True:
+        digits = _ROW_SEED_ALPHABET[value % 36] + digits
+        value //= 36
+        if value == 0:
+            break
+    suffix = "".join(
+        _ROW_SEED_ALPHABET[b % 36] for b in os.urandom(6)
+    )
+    return f"row-{digits}-{suffix}"
+
+
+def _now_ms() -> int:
+    """Epoch milliseconds (the TS ``Date.now()``)."""
+    return int(time.time() * 1000)
+
+
+def summarize_tool_args(args: Any) -> str:
+    """One-line preview of a tool call's arguments — the TS tool-display
+    ``fallbackSummary`` semantics: ``previewText(safeStringify(args), 88)``,
+    with an empty-object summary collapsing to ``""`` so the card header
+    never shows a bare ``{}``."""
+    if args is None:
+        return ""
+    if isinstance(args, Mapping):
+        args = dict(args)
+    summary = preview_text(safe_stringify(args), 88)
+    return "" if summary == "{}" else summary
+
+
+def tool_card_text(
+    adapter: Any,
+    *,
+    name: str,
+    args_summary: str,
+    output: str,
+    status: Literal["running", "success", "error"],
+    expanded: bool,
+    preview_lines: int = TOOL_CARD_PREVIEW_LINES,
+) -> Text:
+    """Render one tool execution as a collapsed card (the defect-2 fix).
+
+    The header line is ``[tool <name>] <arg summary>`` painted through the
+    theme adapter (accent name, muted args). A running card shows a dim
+    ``running…`` row; a settled card shows the result CLAMPED to
+    ``preview_lines`` with a dim ``… (+N lines, ctrl+o to expand)`` tail —
+    the same collapsed/expanded discipline as the framework tool cards
+    (``view:expandTools`` flips ``expanded`` and the card repaints).
+    """
+    header = Text()
+    header.append_text(adapter.color("accent", f"[tool {name}]"))
+    if args_summary:
+        header.append(" ")
+        header.append_text(adapter.muted(args_summary))
+    rows: list[Text] = [header]
+
+    if status == "running":
+        rows.append(adapter.dim("  running…"))
+        return Text("\n").join(rows)
+
+    body = output.strip()
+    if not body:
+        rows.append(adapter.dim("  (no output)"))
+        return Text("\n").join(rows)
+
+    lines = body.splitlines()
+    visible = lines if expanded else lines[:preview_lines]
+    hidden = len(lines) - len(visible)
+    for line in visible:
+        if status == "error":
+            rows.append(adapter.color("error", f"  {line}"))
+        else:
+            rows.append(Text(f"  {line}"))
+    if hidden > 0:
+        rows.append(adapter.dim(f"  … (+{hidden} lines, ctrl+o to expand)"))
+    return Text("\n").join(rows)
+
+
+# ---------------------------------------------------------------------------
+# The conductor-signal relay
+# ---------------------------------------------------------------------------
+
+
+class ConductorSignalMessage(Message):
+    """One conductor :data:`SessionSignal` marshalled into Textual's message
+    pump (the analogue of the reference app's ``AgentEventMessage``)."""
+
+    def __init__(self, signal: SessionSignal) -> None:
+        self.signal = signal
+        super().__init__()
+
+
+# ---------------------------------------------------------------------------
+# Live streaming segments (the risk-2 redesign)
+# ---------------------------------------------------------------------------
+
+
+@dataclass(slots=True)
+class _LiveSegment:
+    """One open streaming segment: the ledger row it grows, the accumulated
+    text fed into it, and the retained ``StreamingMarkdown`` it paints into.
+
+    Replaces the TS ``liveAnswer``/``answerText`` ref pair. A closed segment
+    has every field reset; a delta arriving on a closed segment mints a fresh
+    row + widget, so a post-tool narration can never run on into (or clip the
+    first delta of) the previous one.
+    """
+
+    row_id: str | None = None
+    text: str = ""
+    widget: StreamingMarkdown | None = None
+
+    def reset(self) -> None:
+        self.row_id = None
+        self.text = ""
+        self.widget = None
+
+
+@dataclass(slots=True)
+class _ToolCard:
+    """One live tool-execution card mounted in the streaming tail.
+
+    ``tool_start`` mints it (header + ``running…``), ``tool_end`` settles it
+    with the clamped result, ``view:expandTools`` repaints it expanded, and
+    the turn settling drops it (the ``MessageList`` then renders the settled
+    tool call/result cards from ``conductor.messages()``).
+    """
+
+    name: str
+    args_summary: str = ""
+    output: str = ""
+    status: Literal["running", "success", "error"] = "running"
+    widget: Static | None = None
+
+
+# ---------------------------------------------------------------------------
+# The app
+# ---------------------------------------------------------------------------
+
+#: Chords that must be claimed at app priority. ``ctrl+u`` is editor-consumed
+#: (``deleteToLineStart``) below priority; ``ctrl+c`` must shadow Textual's
+#: built-in App quit binding. Everything else bubbles from the focused editor
+#: untouched, so plain (non-priority) bindings suffice.
+_PRIORITY_CHORDS: Final[frozenset[str]] = frozenset({"ctrl+c", "ctrl+u"})
+
+
+def _build_bindings() -> list[BindingType]:
+    """Derive the app ``BINDINGS`` rows from the pure
+    :data:`~induscode.console.input.INTENT_TABLE` — one parameterised
+    ``intent`` action per chord, so the chord→verb matrix stays data."""
+    return [
+        Binding(
+            key,
+            f"intent({key!r})",
+            show=False,
+            priority=key in _PRIORITY_CHORDS,
+        )
+        for key in INTENT_TABLE
+    ]
+
+
+class ConsoleApp(App[int]):
+    """The interactive console surface: banner, transcript, live streaming
+    tail, task panel, prompt editor, suggestion overlay, and status strip —
+    driven by conductor signals folded through the console reducer into
+    retained widgets."""
+
+    TITLE = _DEFAULT_TITLE
+
+    # The prompt editor ALWAYS holds keyboard focus while no modal is open, so
+    # typing always lands in the composer (owner bug: text could not be typed
+    # because Textual auto-focused the FIRST focusable widget — the transcript
+    # scroll — over the on_mount editor focus, and a click on the transcript
+    # then trapped focus there). ``AUTO_FOCUS`` is Textual's canonical screen-
+    # mount focus seam: it focuses ``#editor`` when the screen mounts instead of
+    # defaulting to ``"*"`` (the first focusable widget). The transcript and the
+    # live tail are additionally made non-focusable in ``compose`` so they can
+    # never win focus at all; keyboard scroll is handled by the app intents and
+    # mouse-wheel scroll still works on a non-focusable scroll view.
+    AUTO_FOCUS: ClassVar[str] = "#editor"
+
+    # The console owns ctrl+p (model rotation); Textual's palette would
+    # otherwise shadow it.
+    ENABLE_COMMAND_PALETTE: ClassVar[bool] = False
+
+    # Mouse text-selection is OFF (the Ink console had none): Textual's
+    # screen-level selection drag asserts `content_widget.parent` is a
+    # Widget, which fires when the drag resolves to the Screen itself
+    # (its parent is the App) — textual/screen.py `_forward_event`,
+    # `assert isinstance(content_widget.parent, Widget)`. The app-level
+    # ALLOW_SELECT gate is checked on every MouseDown before selection
+    # starts, so disabling it here removes the whole crash path.
+    ALLOW_SELECT: ClassVar[bool] = False
+
+    CSS = """
+    Screen {
+        padding: 0 1;
+    }
+    /* The scrolling surface fills every row above the docked chrome: the
+       transcript (banner + settled rows) takes the leftover height, and the
+       live tail grows beneath it (capped, and self-scrolling) so the editor
+       and the ctx footer never get pushed off-screen. */
+    #transcript {
+        height: 1fr;
+    }
+    #live-tail {
+        height: auto;
+        max-height: 50%;
+    }
+    /* The bottom chrome — task panel, prompt editor, suggestion dropdown, and
+       the status/ctx strip — is one container DOCKED to the bottom edge, so
+       the input field and the ctx footer are ALWAYS pinned at the bottom of
+       the screen regardless of how long the conversation grows (parity with
+       the TS surface: scrolling transcript on top, fixed input + footer
+       below). Docking the whole strip (rather than each piece) reserves a
+       single bottom band and keeps the pieces stacked in document order. */
+    #chrome {
+        dock: bottom;
+        height: auto;
+    }
+    /* The prompt editor MUST be sized here explicitly. The framework
+       ``PromptEditor`` (a Textual ``TextArea``) ships ``height: auto;
+       max-height: 30%`` in its DEFAULT_CSS and inherits ``TextArea``'s
+       ``tall`` border (2 gutter rows). Left as-is, that box COLLAPSES to its
+       border inside the ``height: auto`` docked ``#chrome``: the percentage
+       ``max-height: 30%`` resolves against the parent's degenerate auto
+       height, the content viewport is clamped to 0 visible rows, and the
+       editor renders only its top+bottom border edges with NO content row —
+       typed text and the cursor are invisible (owner-confirmed bug). The fix
+       is to pin a deterministic row budget: ``min-height: 3`` guarantees the
+       single-line composer always has its 1 content row between the 2 border
+       rows (so the caret and glyphs are visible the moment you type), while
+       ``height: auto`` with a FIXED-CELL ``max-height`` (not a percentage)
+       lets the box grow for soft-wrapped multi-line input up to a cap without
+       re-triggering the percentage-against-auto collapse. */
+    #editor {
+        height: auto;
+        min-height: 3;
+        max-height: 12;
+    }
+    #suggestions {
+        height: auto;
+        margin: 0 0 0 2;
+    }
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = _build_bindings()
+
+    def __init__(
+        self,
+        conductor: SessionConductor,
+        *,
+        theme: ConsoleTheme,
+        slash: SlashRegistry,
+        services: OverlayServices | None = None,
+        initial_input: str | None = None,
+        verbose: bool = False,
+        on_exit: Callable[[], None] | None = None,
+        cwd: str | None = None,
+    ) -> None:
+        # Set before super().__init__(): App.__init__ builds the stylesheet,
+        # which calls get_theme_variable_defaults() below.
+        self._console_theme = theme
+        super().__init__()
+        self._conductor = conductor
+        self._slash = slash
+        self._services = services
+        self._initial_input = initial_input
+        self._verbose = verbose
+        self._on_exit = on_exit
+        self._cwd = cwd if cwd is not None else os.getcwd()
+
+        # The single reducer store (UI-local state only; session data is read
+        # from the conductor on each refresh).
+        self._state: ConsoleState = init_console_state(scheme=theme.scheme)
+
+        # Live (non-reducer) values carried between keystrokes.
+        self._chord: ChordLatch = NO_CHORD
+        self._chord_timer: Timer | None = None
+        self._exit_window: ExitWindow = NO_EXIT_WINDOW
+
+        # The open streaming segments, one per signal kind.
+        self._live_answer = _LiveSegment()
+        self._live_reason = _LiveSegment()
+        self._row_seed = 0
+
+        # Live tool-execution cards, keyed by tool-call id.
+        self._tool_executions: dict[str, ToolExecutionState] = {}
+
+        # The live tool cards mounted in the streaming tail, keyed by
+        # tool-call id (cleared when the turn settles into the MessageList).
+        self._tool_cards: dict[str, _ToolCard] = {}
+
+        # Whether collapsed tool output is shown in full (Ctrl+O).
+        self._expand_tools = False
+
+        # The repository branch, read once; the footer omits it outside a repo.
+        self._branch = read_branch(self._cwd)
+
+        # The startup chrome, gathered once at mount (pure fs probes).
+        self._startup_map = self._gather_startup()
+
+        # Widgets are reachable only after compose; guarded by this flag.
+        self._view_ready = False
+        self._unsubscribe: Callable[[], None] | None = None
+
+    # -- theme wiring -------------------------------------------------------
+
+    @property
+    def console_theme(self) -> ConsoleTheme:
+        """The fully-resolved console theme currently applied."""
+        return self._console_theme
+
+    @property
+    def console_state(self) -> ConsoleState:
+        """The current reducer state (read-only; dispatch to change it)."""
+        return self._state
+
+    def get_theme_variable_defaults(self) -> dict[str, str]:
+        theme: ConsoleTheme | None = getattr(self, "_console_theme", None)
+        if theme is None:
+            return {}
+        return theme_variable_defaults(theme.bundle.textual_theme)
+
+    # -- startup gathering ----------------------------------------------------
+
+    def _setting(self, key: str, fallback: Any) -> Any:
+        """A guarded preference read: any fault collapses to the fallback."""
+        if self._services is None:
+            return fallback
+        try:
+            return self._services.settings.get(key)
+        except Exception:
+            return fallback
+
+    def _gather_startup(self) -> StartupMap:
+        last_seen = self._setting("lastSeenVersion", "")
+        return gather_startup(
+            StartupInputs(
+                cwd=self._cwd,
+                home=os.path.expanduser("~"),
+                version=VERSION,
+                last_seen_version=last_seen if isinstance(last_seen, str) else "",
+            )
+        )
+
+    # -- composition ----------------------------------------------------------
+
+    def compose(self) -> ComposeResult:
+        adapter = self._console_theme.adapter
+        snap = self._conductor.snapshot()
+
+        # Policy (parity with the TS surface): the full masthead shows on
+        # every launch unless the quiet preference asks otherwise, and the
+        # changelog is never surfaced at startup — /whats-new is on demand.
+        quiet = bool(self._setting("quietStartup", False)) and not self._verbose
+        sweep = (
+            bool(self._setting("logoSweep", False))
+            and not bool(self._setting("reducedMotion", False))
+            and os.isatty(1)
+        )
+
+        # The banner is SCROLLBACK CONTENT, not fixed chrome (defect-3 fix,
+        # parity with the TS inline frames): it is mounted as the first item
+        # INSIDE the scrolling transcript, so it scrolls away naturally as
+        # messages accumulate. The MessageList's row reconciliation only
+        # touches the row widgets it minted, so the banner is never pruned,
+        # and fresh rows mount after it; the anchored scroll keeps the log
+        # pinned to the bottom once content overflows.
+        transcript = MessageList(
+            adapter,
+            show_thinking=self._state.show_reasoning,
+            show_images=self._state.show_images,
+            expand_tool_outputs=self._expand_tools,
+            max_items=TRANSCRIPT_MAX_ITEMS,
+            id="transcript",
+        )
+        # The transcript is a focusable VerticalScroll by default; make it
+        # non-focusable so it can NEVER hold keyboard focus (the editor always
+        # does). Otherwise Textual would auto-focus it as the first focusable
+        # widget, and a click on the history would trap focus on the scroll
+        # container — typing would then do nothing. Mouse-wheel scrolling still
+        # works on a non-focusable scroll view; keyboard scroll is the app's own
+        # intents. (The framework's own dialogs use this same
+        # ``widget.can_focus = False`` instance toggle.)
+        transcript.can_focus = False
+        with transcript:
+            yield Banner(
+                adapter,
+                model_id=snap.modelId,
+                workspace=self._cwd,
+                version=VERSION,
+                verbose=self._verbose,
+                quiet=quiet,
+                compact=False,
+                sweep=sweep,
+                startup=self._startup_map,
+                id="banner",
+            )
+
+        # The live streaming tail: StreamingMarkdown widgets and tool cards are
+        # mounted in here per narration segment and cleared once the turn
+        # settles into the MessageList above. It is an *anchored* VerticalScroll
+        # (not a plain Vertical) so a long mid-stream narration keeps its newest
+        # line in view within its capped band instead of clipping off the bottom
+        # — the same scroll-to-newest discipline the transcript above uses.
+        live_tail = VerticalScroll(id="live-tail")
+        # Like the transcript: a non-focusable scroll view so it can never steal
+        # keyboard focus from the editor (mouse-wheel scroll still works).
+        live_tail.can_focus = False
+        yield live_tail
+
+        # The bottom chrome, docked as one band (see the CSS note on #chrome):
+        # the task panel sits just above the editor (TS parity — the task strip
+        # renders above the input), the editor + suggestion dropdown next, and
+        # the status/ctx strip pinned at the very bottom. Stacked in document
+        # order inside the docked container so the ctx footer is the last row.
+        with Vertical(id="chrome"):
+            yield TaskPanel(
+                adapter,
+                snapshot=None,
+                tool_executions={},
+                expand_tool_outputs=self._expand_tools,
+                pending_messages=(),
+                id="tasks",
+            )
+
+            editor = PromptEditor(
+                autocomplete_provider=ConsoleAutocompleteProvider(
+                    self._slash, create_dir_reader(self._cwd)
+                ),
+                id="editor",
+            )
+            yield editor
+
+            suggestions = Static("", id="suggestions")
+            suggestions.display = False
+            yield suggestions
+
+            yield StatusBar(
+                adapter,
+                snapshot=None,
+                branch=self._branch,
+                provider_count=count_providers(self._conductor),
+                status=None,
+                id="statusbar",
+            )
+
+    # -- lifecycle --------------------------------------------------------------
+
+    def on_mount(self) -> None:
+        # Register every shipped scheme so `scheme:set` (and the theme
+        # picker's live preview) is a native `app.theme = name` retheme.
+        from .theme import THEMES
+
+        for theme in THEMES.values():
+            self.register_theme(theme.bundle.textual_theme)
+        self.theme = self._console_theme.scheme
+
+        self._view_ready = True
+        self._unsubscribe = self._conductor.subscribe(self._relay_signal)
+        # Anchor the live streaming tail so newly mounted segments/tool cards
+        # keep the newest line in view (the transcript MessageList anchors
+        # itself in its own on_mount).
+        self.query_one("#live-tail", VerticalScroll).anchor()
+        # Focus the editor robustly. ``AUTO_FOCUS = "#editor"`` already focuses
+        # it on screen mount; this immediate call plus a post-refresh re-assert
+        # belt-and-suspenders against any late auto-focus so the composer is the
+        # focused widget the instant the surface appears.
+        self._focus_editor()
+        self.call_after_refresh(self._focus_editor)
+        self._refresh_view()
+
+        # The signed-in account label for the personalized welcome line.
+        if self._services is not None:
+            self.run_worker(self._load_welcome_account(), group="console-startup")
+
+        # An optional first user turn submitted on mount.
+        if self._initial_input is not None and self._initial_input.strip():
+            self.run_worker(
+                self._run_turn(self._initial_input),
+                group="console-submit",
+                exclusive=False,
+            )
+
+    def on_unmount(self) -> None:
+        if self._unsubscribe is not None:
+            self._unsubscribe()
+            self._unsubscribe = None
+
+    # -- keyboard focus discipline -------------------------------------------
+
+    def _modal_open(self) -> bool:
+        """True when a ModalScreen overlay owns the screen — overlays own
+        their own focus, so the console must not yank it back to the editor."""
+        return self.screen is not self.screen_stack[0]
+
+    def _focus_editor(self) -> None:
+        """Return keyboard focus to the prompt editor unless a modal overlay
+        owns the screen. The editor must always be the focused widget while no
+        dialog is open, so typing always lands in the composer. Guarded so it
+        is inert before compose and a no-op while an overlay is up."""
+        if not self._view_ready or self._modal_open():
+            return
+        try:
+            editor = self.query_one("#editor", PromptEditor)
+        except Exception:
+            return
+        if self.focused is not editor:
+            editor.focus()
+
+    def on_click(self, event: object) -> None:
+        """A click anywhere in the console (history, live tail, banner, the
+        chrome strips) returns focus to the editor — so clicking the transcript
+        can never trap focus on a scroll container and leave typing dead. The
+        transcript and live tail are already non-focusable; this is the
+        belt-and-suspenders catch for any other stray click target. No-op while
+        an overlay owns the screen (those dialogs manage their own focus)."""
+        self._focus_editor()
+
+    async def _load_welcome_account(self) -> None:
+        services = self._services
+        if services is None:
+            return
+        try:
+            provider = services.settings.get("defaultProvider")
+            account = await services.vault.default_account(provider)
+        except Exception:
+            return  # the banner falls back to "Welcome back!"
+        if account:
+            self.query_one("#banner", Banner).account = account
+
+    # -- the reducer store --------------------------------------------------------
+
+    def dispatch(self, event: ConsoleEvent) -> None:
+        """Fold one event through the console reducer and push the fresh
+        state into the retained widgets (the retained-mode replacement for
+        the TS re-render)."""
+        self._state = console_reducer(self._state, event)
+        if event.type == "scheme:set":
+            self._apply_scheme(self._state.scheme)
+        self._refresh_view()
+
+    def _apply_scheme(self, scheme: str) -> None:
+        """Re-skin the surface for a committed scheme: swap the resolved
+        console theme, the Textual theme (CSS variables), the banner painter,
+        and the chrome strips' painters; the transcript is rebuilt so settled
+        rows repaint under the new adapter."""
+        theme = resolve_theme(scheme)
+        self._console_theme = theme
+        try:
+            self.theme = theme.scheme
+        except Exception:
+            pass  # an unregistered name keeps the current Textual theme
+        if not self._view_ready:
+            return
+        adapter = theme.adapter
+        self.query_one("#banner", Banner).theme = adapter
+        bar = self.query_one("#statusbar", StatusBar)
+        bar.status_line.theme = adapter
+        bar.footer.theme = adapter
+        self.query_one("#tasks", TaskPanel).theme = adapter
+        transcript = self.query_one("#transcript", MessageList)
+        # The MessageList captures its painter at construction; swap it and
+        # rebuild so history repaints (a deliberate reach-in — the framework
+        # exposes no setter, and re-mounting the list would lose scroll).
+        transcript._theme = adapter  # noqa: SLF001
+        self._repaint_tool_cards()
+        self._rebuild_transcript()
+
+    def _rebuild_transcript(self) -> None:
+        """Drop and re-mount every transcript row (used when a render flag —
+        show_thinking / expand_tool_outputs / the painter — changes)."""
+        transcript = self.query_one("#transcript", MessageList)
+        transcript.show_thinking = self._state.show_reasoning
+        transcript.show_images = self._state.show_images
+        transcript.expand_tool_outputs = self._expand_tools
+        transcript.sync((), ())
+        self._refresh_view()
+
+    # -- view refresh ---------------------------------------------------------------
+
+    def _scroll_to_bottom(self) -> None:
+        """Keep the scrolling surface pinned to the newest content.
+
+        Both scroll regions are *anchored* (the transcript MessageList and the
+        live tail), so they follow growth automatically while the user is at the
+        bottom and stay put once the user scrolls up. This belt-and-suspenders
+        call re-asserts the bottom on every content event — a settled row synced
+        into the transcript, a streamed delta, a tool card, a status change, and
+        right after submit — so the default and post-submit landing is always the
+        newest line, even when an event grows content without moving scroll_y
+        (which is what re-arms the anchor). It never yanks a user who has
+        scrolled up: ``scroll_end`` respects a released anchor, and the anchor is
+        only re-armed once the user returns to the bottom themselves.
+        """
+        if not self._view_ready:
+            return
+        for selector in ("#transcript", "#live-tail"):
+            try:
+                region = self.query_one(selector, VerticalScroll)
+            except Exception:
+                continue
+            if region.is_anchored and not region._anchor_released:  # noqa: SLF001
+                region.scroll_end(animate=False, immediate=True)
+
+    def _refresh_view(self) -> None:
+        """Push the current conductor snapshot + reducer state into the
+        retained widgets."""
+        if not self._view_ready:
+            return
+        conductor = self._conductor
+        messages = list(conductor.messages())
+        snapshot = project_snapshot(conductor, self._services, messages, self._cwd)
+
+        self.query_one("#transcript", MessageList).sync(
+            messages, list(self._state.blocks)
+        )
+
+        # The pending-input queue, projected to the framework's panel shape.
+        pending: list[PendingMessageItem] = [
+            PendingMessageItem(
+                id=f"pending-{index}-{entry.mode}",
+                mode=entry.mode,
+                text=entry.text,
+                source="session",
+            )
+            for index, entry in enumerate(conductor.pending_inputs())
+        ]
+        tasks = self.query_one("#tasks", TaskPanel)
+        tasks.snapshot = snapshot
+        tasks.tool_executions = dict(self._tool_executions)
+        tasks.expand_tool_outputs = self._expand_tools
+        tasks.pending_messages = pending
+
+        self.query_one("#statusbar", StatusBar).update_state(
+            snapshot,
+            branch=self._branch,
+            provider_count=count_providers(conductor),
+            status=self._state.status,
+        )
+
+        self.query_one("#banner", Banner).model_id = conductor.snapshot().modelId
+
+        # Terminal title (OSC 2) through Textual's title machinery — never a
+        # raw escape write (risk 4).
+        name = conductor.session_name()
+        self.title = name if name else _DEFAULT_TITLE
+
+        # Land the view at the newest content (a synced settled row, a status
+        # change, a post-submit refresh) unless the user has scrolled up.
+        self._scroll_to_bottom()
+
+    # -- conductor signal folding -------------------------------------------------------
+
+    def _relay_signal(self, signal: SessionSignal) -> None:
+        """Marshal one conductor signal into the app's message pump. The hub
+        emits synchronously on the app's own loop (the submit worker drives
+        the conductor there), so posting directly is loop-safe."""
+        self.post_message(ConductorSignalMessage(signal))
+
+    async def on_conductor_signal_message(self, message: ConductorSignalMessage) -> None:
+        """Project one :data:`SessionSignal` into reducer events + retained
+        widget updates — the port of the TS subscription switch."""
+        signal = message.signal
+        kind = signal.kind
+
+        if kind == "prompt":
+            # The user's turn is already readable from conductor.messages();
+            # the trailing refresh re-syncs the MessageList so it echoes the
+            # user row immediately rather than on the first reply token.
+            pass
+        elif kind == "text":
+            await self._stream_delta("answer", signal.delta)
+        elif kind == "thinking":
+            await self._stream_delta("reason", signal.delta)
+        elif kind == "tool_start":
+            # End the current narration segment so assistant text after this
+            # tool call starts a fresh row + widget instead of running on.
+            await self._close_live_segments(drop=False)
+            self.dispatch(
+                RowsAppend(
+                    row=ViewRow(
+                        id=f"tool-{signal.id}",
+                        kind="toolRun",
+                        text=signal.name,
+                        run_id=signal.id,
+                    )
+                )
+            )
+            # The signal carries only (id, name); the call's arguments are
+            # read from the just-settled assistant message so the card (and
+            # the TaskPanel) can show the arg summary instead of "".
+            args = self._tool_call_args(signal.id)
+            args_summary = summarize_tool_args(args)
+            self._tool_executions[signal.id] = ToolExecutionState(
+                toolCallId=signal.id,
+                toolName=signal.name,
+                argsText=args_summary,
+                status="running",
+                outputText="",
+                args=args,
+                updatedAt=_now_ms(),
+            )
+            await self._open_tool_card(signal.id, signal.name, args_summary)
+        elif kind == "tool_end":
+            self.dispatch(
+                RowsPatch(id=f"tool-{signal.id}", text="done" if signal.ok else "failed")
+            )
+            # The result message is already appended when this signal is
+            # handled (the relay defers through the message pump), so the
+            # card body is the real tool output, clamped.
+            output = self._tool_result_text(signal.id)
+            prior = self._tool_executions.get(signal.id)
+            if prior is not None:
+                self._tool_executions[signal.id] = replace(
+                    prior,
+                    status="success" if signal.ok else "error",
+                    outputText=output,
+                    updatedAt=_now_ms(),
+                )
+            self._settle_tool_card(signal.id, ok=signal.ok, output=output)
+        elif kind == "turn_end":
+            await self._close_live_segments(drop=True)
+            self.dispatch(BusySet(busy=False))
+            self.dispatch(Tick())
+        elif kind == "compacted":
+            self.dispatch(
+                StatusSet(status=StatusMessage(kind="info", text="Conversation condensed."))
+            )
+        elif kind == "persisted":
+            self.dispatch(Tick())
+        elif kind == "fault":
+            await self._close_live_segments(drop=True)
+            self.dispatch(BusySet(busy=False))
+            self.dispatch(
+                StatusSet(status=StatusMessage(kind="error", text=signal.fault.message))
+            )
+        elif kind == "queue":
+            # Depth is re-read from pending_inputs() on refresh.
+            pass
+        elif kind == "idle":
+            self.dispatch(BusySet(busy=False))
+
+        self._refresh_view()
+
+    # -- streaming segments ---------------------------------------------------------------
+
+    def _segment(self, kind: Literal["answer", "reason"]) -> _LiveSegment:
+        return self._live_answer if kind == "answer" else self._live_reason
+
+    async def _stream_delta(self, kind: Literal["answer", "reason"], delta: str) -> None:
+        """Fold one streamed delta into the segment's ledger row and its
+        retained ``StreamingMarkdown``. Reason deltas paint into the live
+        tail only while ``show_reasoning`` is on (the ledger row is kept
+        regardless, exactly as TS dispatched reason rows unconditionally)."""
+        if not delta:
+            return
+        segment = self._segment(kind)
+        if segment.row_id is None:
+            # A new narration segment begins: mint a fresh row seeded with
+            # this first delta (the TS first-delta-clipping regression is
+            # structurally impossible — a closed segment has no carried text).
+            segment.row_id = fresh_row_id(self._row_seed)
+            self._row_seed += 1
+            segment.text = delta
+            self.dispatch(
+                RowsAppend(
+                    row=ViewRow(
+                        id=segment.row_id,
+                        kind="answer" if kind == "answer" else "reason",
+                        text=segment.text,
+                    )
+                )
+            )
+        else:
+            segment.text += delta
+            self.dispatch(RowsPatch(id=segment.row_id, text=segment.text))
+
+        paint = kind == "answer" or self._state.show_reasoning
+        if not paint:
+            return
+        if segment.widget is None:
+            segment.widget = StreamingMarkdown(dim=kind == "reason")
+            await self.query_one("#live-tail", VerticalScroll).mount(segment.widget)
+        await segment.widget.write(delta)
+        self._scroll_to_bottom()
+
+    async def _close_live_segments(self, *, drop: bool) -> None:
+        """Settle both open segments. With ``drop`` the live tail is emptied
+        (the settled turn is now rendered by the MessageList); without it the
+        settled widgets stay visible mid-turn (text preceding a tool call)."""
+        for segment in (self._live_answer, self._live_reason):
+            if segment.widget is not None:
+                await segment.widget.settle()
+            segment.reset()
+        if drop:
+            self._tool_cards.clear()
+            await self.query_one("#live-tail", VerticalScroll).remove_children()
+
+    # -- tool cards -----------------------------------------------------------
+
+    def _tool_call_args(self, call_id: str) -> Any:
+        """The arguments of the tool call ``call_id``, read from the settled
+        assistant message (the ``tool_start`` signal carries only id+name)."""
+        for message in reversed(list(self._conductor.messages())):
+            if getattr(message, "role", None) != "assistant":
+                continue
+            for part in getattr(message, "content", ()) or ():
+                if (
+                    getattr(part, "type", None) == "toolCall"
+                    and getattr(part, "id", None) == call_id
+                ):
+                    return getattr(part, "arguments", None)
+        return None
+
+    def _tool_result_text(self, call_id: str) -> str:
+        """The plain text of the tool result for ``call_id`` (empty when the
+        result message has not landed — the card then shows ``(no output)``)."""
+        for message in reversed(list(self._conductor.messages())):
+            if (
+                getattr(message, "role", None) == "toolResult"
+                and getattr(message, "toolCallId", None) == call_id
+            ):
+                return extract_tool_text(getattr(message, "content", None), False)
+        return ""
+
+    def _tool_card_render(self, card: _ToolCard) -> Text:
+        return tool_card_text(
+            self._console_theme.adapter,
+            name=card.name,
+            args_summary=card.args_summary,
+            output=card.output,
+            status=card.status,
+            expanded=self._expand_tools,
+        )
+
+    async def _open_tool_card(self, call_id: str, name: str, args_summary: str) -> None:
+        """Mount the running card for one tool execution into the live tail
+        (the defect-2 fix: a styled, clamped card instead of a raw dump)."""
+        card = _ToolCard(name=name, args_summary=args_summary)
+        card.widget = Static(self._tool_card_render(card), classes="tool-card")
+        self._tool_cards[call_id] = card
+        await self.query_one("#live-tail", VerticalScroll).mount(card.widget)
+        self._scroll_to_bottom()
+
+    def _settle_tool_card(self, call_id: str, *, ok: bool, output: str) -> None:
+        """Settle the live card with its clamped result (collapsed unless
+        Ctrl+O has expanded tool output)."""
+        card = self._tool_cards.get(call_id)
+        if card is None:
+            return
+        card.status = "success" if ok else "error"
+        card.output = output
+        if card.widget is not None:
+            card.widget.update(self._tool_card_render(card))
+            self._scroll_to_bottom()
+
+    def _repaint_tool_cards(self) -> None:
+        """Repaint every mounted live card (expand toggle / scheme switch)."""
+        for card in self._tool_cards.values():
+            if card.widget is not None:
+                card.widget.update(self._tool_card_render(card))
+
+    def stream_parity_report(self) -> list[str]:
+        """The risk-2 parity check: every open segment's ledger row must
+        exist and carry exactly the text fed into its retained widget, and
+        every tracked tool execution must have its ``toolRun`` ledger row.
+        Returns human-readable violations (empty == in parity)."""
+        problems: list[str] = []
+        for label, segment in (("answer", self._live_answer), ("reason", self._live_reason)):
+            if segment.row_id is None:
+                continue
+            row = next((r for r in self._state.rows if r.id == segment.row_id), None)
+            if row is None:
+                problems.append(f"live {label} row {segment.row_id!r} missing from ledger")
+            elif row.text != segment.text:
+                problems.append(
+                    f"live {label} row {segment.row_id!r} ledger text diverged from stream"
+                )
+        for run_id in self._tool_executions:
+            if not any(
+                r.kind == "toolRun" and r.run_id == run_id for r in self._state.rows
+            ):
+                problems.append(f"tool execution {run_id!r} has no toolRun ledger row")
+        return problems
+
+    # -- submit routing -------------------------------------------------------------------
+
+    def on_prompt_editor_submitted(self, message: PromptEditor.Submitted) -> None:
+        message.stop()
+        if not message.text.strip():
+            return
+        self.run_worker(
+            self._handle_submit(message.text), group="console-submit", exclusive=False
+        )
+
+    async def _handle_submit(self, raw: str) -> None:
+        """Route one committed line — verbatim TS order: the ``!``/``!!``
+        bash escape, then slash resolution, then a plain prompt. The editor
+        has already expanded paste markers and cleared its buffer."""
+        trimmed = raw.strip()
+        if not trimmed:
+            return
+        self.query_one("#editor", PromptEditor).add_to_history(trimmed)
+
+        # A leading "!" escapes to the shell rather than the model. "!!" runs
+        # the command but keeps its output out of the conversation context.
+        if trimmed.startswith("!"):
+            exclude = trimmed.startswith("!!")
+            command = trimmed[2 if exclude else 1 :].strip()
+            if not command:
+                return
+            note = ViewRow(
+                id=fresh_row_id(self._row_seed), kind="notice", text=f"! {command}"
+            )
+            self._row_seed += 1
+            self.dispatch(RowsAppend(row=note))
+            self.dispatch(
+                StatusSet(status=StatusMessage(kind="busy", text=f"Running: {command}"))
+            )
+            try:
+                from induscode.conductor import ExecuteBashOptions
+
+                outcome = await self._conductor.execute_bash(
+                    command, ExecuteBashOptions(excludeFromContext=exclude)
+                )
+                self.dispatch(
+                    StatusSet(
+                        status=StatusMessage(
+                            kind="info" if outcome.exitCode == 0 else "error",
+                            text=f"Shell exited {outcome.exitCode}.",
+                        )
+                    )
+                )
+            except Exception as err:
+                self.dispatch(
+                    StatusSet(
+                        status=StatusMessage(kind="error", text=str(err) or repr(err))
+                    )
+                )
+            return
+
+        # Try a slash command next.
+        resolution = resolve_slash(trimmed, self._slash)
+        if resolution.kind == "match":
+            ctx = SlashContext(
+                args=resolution.args,
+                conductor=self._conductor,
+                dispatch=self.dispatch,
+                open_modal=self._open_modal,
+                close_modal=lambda: self.dispatch(ModalClose()),
+                request_exit=self._request_exit,
+                set_status=lambda status: self.dispatch(StatusSet(status=status)),
+                set_buffer=self._set_buffer,
+                append_block=lambda block: self.dispatch(BlockAppend(block=block)),
+            )
+            outcome = await resolution.command.run(ctx)
+            if outcome.kind == "prompt":
+                await self._run_turn(outcome.text)
+            return
+        if resolution.kind == "miss":
+            self.dispatch(
+                StatusSet(
+                    status=StatusMessage(
+                        kind="warning", text=f"Unknown command: /{resolution.name}"
+                    )
+                )
+            )
+            return
+
+        # A plain prompt.
+        await self._run_turn(raw)
+
+    async def _run_turn(self, text: str) -> None:
+        """Append the prompt ledger row, flip busy, and drive the conductor
+        to settlement. A busy conductor queues the input itself (the
+        queued-when-busy semantics live in ``SessionConductor.submit``)."""
+        row = ViewRow(id=fresh_row_id(self._row_seed), kind="prompt", text=text)
+        self._row_seed += 1
+        self.dispatch(RowsAppend(row=row))
+        self.dispatch(BusySet(busy=True))
+        try:
+            await self._conductor.submit(text)
+        except Exception as err:
+            self.dispatch(BusySet(busy=False))
+            self.dispatch(
+                StatusSet(status=StatusMessage(kind="error", text=str(err) or repr(err)))
+            )
+        self._refresh_view()
+        # Settle at the newest line with the composer focused, ready for the
+        # next turn (the refresh above already re-asserted the bottom).
+        if self._view_ready and self.screen is self.screen_stack[0]:
+            self.query_one("#editor", PromptEditor).focus()
+
+    def _set_buffer(self, value: str) -> None:
+        self.query_one("#editor", PromptEditor).set_text(value)
+
+    def _request_exit(self) -> None:
+        if self._on_exit is not None:
+            try:
+                self._on_exit()
+            except Exception:
+                pass
+        self.exit(0)
+
+    # -- overlays ---------------------------------------------------------------------------
+
+    def _open_modal(self, kind: str, payload: object | None = None) -> None:
+        """The ``SlashContext.open_modal`` seam: validate the kind and raise
+        the overlay (an unknown kind is ignored, as the TS host rendered
+        nothing for one)."""
+        if kind in MODAL_KINDS:
+            self._raise_overlay(kind, payload)  # type: ignore[arg-type]
+
+    def _raise_overlay(self, kind: ModalKind, payload: object | None = None) -> None:
+        """Dispatch ``modal:open`` and run the awaited overlay flow in a
+        worker (``push_screen_wait`` demands one)."""
+        if kind == "none":
+            return
+        self.dispatch(ModalOpen(kind=kind, payload=payload))
+        self.run_worker(
+            self._overlay_flow(kind, payload), group="console-overlay", exclusive=False
+        )
+
+    async def _overlay_flow(self, kind: ModalKind, payload: object | None) -> None:
+        try:
+            outcome = await open_overlay(self, kind, payload, self._services)
+            for event in outcome.events:
+                self.dispatch(event)
+        finally:
+            self.dispatch(ModalClose())
+
+    # -- suggestion overlay -------------------------------------------------------------------
+
+    def on_prompt_editor_suggestions_changed(
+        self, message: PromptEditor.SuggestionsChanged
+    ) -> None:
+        message.stop()
+        panel = self.query_one("#suggestions", Static)
+        adapter = self._console_theme.adapter
+        lines: list[Text] = []
+        for index, item in enumerate(message.items[:_SUGGESTION_WINDOW]):
+            chosen = index == message.selected_index
+            line = Text("▸ " if chosen else "  ")
+            label = adapter.color("accent", item.label) if chosen else Text(item.label)
+            line.append_text(label)
+            if item.description:
+                line.append("  ")
+                line.append_text(adapter.dim(item.description))
+            lines.append(line)
+        panel.update(Text("\n").join(lines))
+        panel.display = len(lines) > 0
+
+    def on_prompt_editor_suggestions_closed(
+        self, message: PromptEditor.SuggestionsClosed
+    ) -> None:
+        message.stop()
+        panel = self.query_one("#suggestions", Static)
+        panel.update("")
+        panel.display = False
+
+    # -- intents -------------------------------------------------------------------------------
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        """Gate the intent bindings while a dialog owns the screen — the TS
+        ``useInput`` was inactive whenever a modal was up. Ctrl+C stays live
+        (clear-then-exit must always be reachable); everything else declines
+        so the key forwards on to the dialog's own bindings."""
+        if (
+            action == "intent"
+            and self.screen is not self.screen_stack[0]
+            and parameters
+            and parameters[0] != "ctrl+c"
+        ):
+            return False
+        return super().check_action(action, parameters)
+
+    def _arm_chord(self, next_latch: ChordLatch) -> None:
+        """Carry the chord latch and (re)arm its expiry timer (the TS
+        ``armChord`` + ``CHORD_WINDOW_MS`` timeout)."""
+        self._chord = next_latch
+        if self._chord_timer is not None:
+            self._chord_timer.stop()
+            self._chord_timer = None
+        if next_latch.armed is not None:
+            self._chord_timer = self.set_timer(
+                CHORD_WINDOW_MS / 1000, self._expire_chord
+            )
+
+    def _expire_chord(self) -> None:
+        self._chord = NO_CHORD
+        self._chord_timer = None
+
+    def action_intent(self, key: str) -> None:
+        """Dispatch one app-level chord: look the intent up in the pure
+        :data:`INTENT_TABLE`, advance the double-tap latch, and run the verb
+        — the port of the TS ``useInput`` switch, minus the editor-delegated
+        verbs the framework editor consumes before keys reach the app."""
+        intent = INTENT_TABLE.get(key)
+        if intent is None:
+            return
+
+        step = advance_chord(self._chord, intent)
+        self._arm_chord(step.next)
+        if step.fired == "clear×2":
+            self._request_exit()
+            return
+        if step.fired == "dismiss×2":
+            self._fire_double_escape()
+            return
+
+        self._dispatch_intent(intent)
+
+    def _fire_double_escape(self) -> None:
+        """Double-Escape is configurable: the preference selects whether the
+        chord opens the transcript tree, the prior-turn fork picker, or wipes
+        the composer buffer."""
+        action = read_double_escape_action(self._services)
+        if action == "tree":
+            self._raise_overlay("tree")
+        elif action == "fork":
+            self._raise_overlay("userTurns")
+        else:
+            self._set_buffer("")
+
+    def _dispatch_intent(self, intent: ConsoleIntent) -> None:
+        verb = intent.verb
+
+        if verb == "flow:interrupt":
+            # Ctrl+C: clear-then-exit. The pure machine decides; the app
+            # performs (abort a busy turn / clear the composer / arm the
+            # window / exit on the second empty-buffer press inside it).
+            editor = self.query_one("#editor", PromptEditor)
+            step = advance_exit_window(
+                self._exit_window,
+                busy=self._state.busy,
+                buffer_empty=len(editor.get_text()) == 0,
+                now_ms=time.monotonic() * 1000,
+            )
+            self._exit_window = step.next
+            if step.action == "abort":
+                self._conductor.abort()
+            elif step.action == "clear":
+                editor.set_text("")
+            elif step.action == "exit":
+                self._request_exit()
+            return
+
+        if verb == "flow:dismiss":
+            # A single Escape: drop an overlay (defensive — the dialog's own
+            # Esc normally races this away), else stop a running turn.
+            if self._state.modal.kind != "none":
+                self.dispatch(ModalClose())
+            elif self._state.busy:
+                self._conductor.abort()
+            return
+
+        if verb == "edit:clearLine":
+            # Ctrl+U wipes the whole composer line (TS `buffer:set ""`); the
+            # chord latch above turns a double-tap into a request to exit.
+            self._set_buffer("")
+            return
+
+        if verb == "flow:suspend":
+            # Background this process via job control; the shell foregrounds
+            # it again on `fg`, where Textual re-attaches to the terminal.
+            try:
+                self.action_suspend_process()
+            except Exception:
+                pass  # headless / unsupported drivers cannot suspend
+            return
+
+        if verb == "flow:cycleModel":
+            cycle = getattr(self._conductor, "cycle_model", None)
+            if callable(cycle):
+                try:
+                    cycle("")
+                except Exception:
+                    pass
+            self._refresh_view()
+            return
+
+        if verb == "model:cycleThinking":
+            level = self._conductor.cycle_thinking_level()
+            self.dispatch(
+                StatusSet(
+                    status=StatusMessage(kind="info", text=f"Reasoning effort: {level}.")
+                )
+            )
+            return
+
+        if verb == "view:toggleReasoning":
+            self.dispatch(ToggleReasoning())
+            self._rebuild_transcript()
+            return
+
+        if verb == "view:expandTools":
+            self._expand_tools = not self._expand_tools
+            self._repaint_tool_cards()
+            self._rebuild_transcript()
+            return
+
+        if verb == "queue:dequeue":
+            restored = self._conductor.dequeue_last()
+            if restored is not None:
+                self._set_buffer(restored)
+            else:
+                self.dispatch(
+                    StatusSet(
+                        status=StatusMessage(
+                            kind="warning", text="No queued message to restore."
+                        )
+                    )
+                )
+            return
+
+        if verb == "input:pasteImage":
+            path = read_clipboard_image()
+            if path is not None:
+                editor = self.query_one("#editor", PromptEditor)
+                current = editor.get_text()
+                sep = " " if current and not current[-1].isspace() else ""
+                editor.insert_text_at_cursor(f"{sep}{path}")
+            else:
+                self.dispatch(
+                    StatusSet(
+                        status=StatusMessage(
+                            kind="warning", text="No image on the clipboard."
+                        )
+                    )
+                )
+            return
+
+        if verb == "input:externalEditor":
+            editor = self.query_one("#editor", PromptEditor)
+            try:
+                with self.suspend():
+                    edited = open_in_external_editor(editor.get_text())
+            except Exception:
+                return  # suspend unsupported (headless): leave the buffer be
+            if edited is not None:
+                editor.set_text(edited)
+            return
+
+        if verb == "overlay:open":
+            if intent.overlay is not None and intent.overlay != "none":
+                self._open_modal(intent.overlay)
+            return
+
+        # "none" and anything editor-delegated: inert at the app layer.
+
+    # -- exit transcript ---------------------------------------------------------------------------
+
+    def exit_transcript(self) -> Text | None:
+        """The accumulated conversation as plain Rich text, printed by the
+        mount into real terminal scrollback once the alternate screen is gone
+        (the framework's exit-transcript pattern — Textual erases the
+        alternate screen on exit, unlike the inline Ink frames)."""
+        return exit_transcript_text(list(self._conductor.messages()))