systemr-cli 2.1.1__tar.gz → 2.2.0__tar.gz

{systemr_cli-2.1.1 → systemr_cli-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: systemr-cli
-Version: 2.1.1
+Version: 2.2.0
 Summary: System R AI — trading operating system for agents
 Author-email: System R AI <ashim@systemr.ai>
 License-Expression: MIT

{systemr_cli-2.1.1 → systemr_cli-2.2.0}/neo/__init__.py

@@ -1,3 +1,3 @@
 """System R CLI — trading operating system in your terminal."""
 
-__version__ = "2.1.1"
+__version__ = "2.2.0"

{systemr_cli-2.1.1 → systemr_cli-2.2.0}/neo/commands/chat_commands.py

@@ -204,8 +204,7 @@ def chat(ctx: click.Context, model_name: str | None, research: bool, resume: boo
         db_session_id = store.create_chat_session()
 
     from neo.config import get_api_key
-    from neo.tui import ChatTUI
-    from neo.chat_runner import run_chat_tui
+    from neo.display.theme import print_prompt_bar
 
     # Only print banner if not already shown by _show_home_and_chat
     banner_shown = (ctx.obj or {}).get("banner_shown", False)
@@ -213,58 +212,180 @@ def chat(ctx: click.Context, model_name: str | None, research: bool, resume: boo
         print_banner()
         console.print(f"  [{GREEN}]● connected[/]")
 
+    # Session state
+    failover = load_failover_chain()
+    if model_name:
+        failover.pinned_model = model_name
+    current_model = model_name
     credits = SessionCredits()
-    history_file = str(SYSTEMR_HOME / "chat_history")
-    display_model = model_name or "sonnet"
+    history_file = SYSTEMR_HOME / "chat_history"
+    loop = asyncio.new_event_loop()
+
+    prompt_session: PromptSession[str] = PromptSession(
+        history=FileHistory(str(history_file)),
+        auto_suggest=AutoSuggestFromHistory(),
+    )
+
+    # Broker state (will be dynamic when broker connection is implemented)
+    connected_broker: str | None = None
+    display_model = current_model or "sonnet"
 
     # Fire session start hook
     fire_hook(HookEvent.PRE_SESSION, context={"model": model_name})
     logger.info("session_started", model=model_name, resume=resume)
 
-    # Create TUI and run
-    tui = ChatTUI(
-        model=display_model,
-        broker=None,
-        history_file=history_file,
-    )
+    try:
+        while True:
+            print_separator()
+            try:
+                user_input = prompt_session.prompt("  ❯ ").strip()
+            except (EOFError, KeyboardInterrupt):
+                console.print()
+                console.print(f"  [{DIM}]Session closed.[/]")
+                break
 
-    async def _run() -> None:
-        # Start TUI in background
-        tui_task = asyncio.create_task(tui.run_async())
-        # Run chat loop
-        try:
-            await run_chat_tui(
-                tui=tui,
-                access_token=token.access_token,
-                credits=credits,
-                store=store,
-                db_session_id=db_session_id,
-                messages=messages,
-                model=model_name,
-                research=research,
+            # Bottom separator + status bar
+            print_separator()
+            print_prompt_bar(model=display_model, broker=connected_broker)
+
+            if not user_input:
+                continue
+
+            # Handle slash commands
+            if user_input.startswith("/"):
+                result = _handle_slash_command(
+                    user_input, messages, current_model,
+                    access_token=token.access_token, credits=credits,
+                )
+                if result == "exit":
+                    console.print(f"\n  [{GREEN_DIM}]Session closed.[/]")
+                    break
+                if result == "clear":
+                    messages.clear()
+                    print_success("Conversation cleared.")
+                    continue
+                if result is not None:
+                    if result.startswith("model:"):
+                        current_model = result.split(":", 1)[1]
+                        failover.pinned_model = current_model
+                        print_success(f"Model: {current_model}")
+                    continue
+
+            store.add_chat_message(db_session_id, "user", user_input)
+            messages.append({"role": "user", "content": user_input})
+
+            # Tool pre-routing: detect tool-invocable requests and execute directly
+            tool_match = match_tool(user_input)
+            if tool_match:
+                render_action(tool_match.tool_name, status="running", result="")
+                try:
+                    tool_result = loop.run_until_complete(
+                        call_tool(tool_match.tool_name, tool_match.arguments)
+                    )
+                    result_data = tool_result.get("result", {})
+                    cost = tool_result.get("cost_usdc") or (
+                        result_data.get("cost_usdc", "") if isinstance(result_data, dict) else ""
+                    )
+                    render_action(
+                        tool_match.tool_name, status="done",
+                        result=f"${cost}" if cost else "done",
+                    )
+
+                    # Display results
+                    if isinstance(result_data, dict):
+                        display_items: list[str] = []
+                        for k, v in result_data.items():
+                            if k in ("cost_usdc",):
+                                continue
+                            if v is not None and str(v).strip():
+                                display_items.append(f"  [{GRAY}]{k}:[/] [{WHITE}]{v}[/]")
+                        if display_items:
+                            console.print()
+                            for item in display_items[:15]:
+                                console.print(item)
+                            console.print()
+
+                    credits.add_response(credits_used=cost, tools=1)
+                    reply = f"Tool {tool_match.tool_name} executed. Result: {json.dumps(result_data)[:200]}"
+                    store.add_chat_message(db_session_id, "assistant", reply)
+                    messages.append({"role": "assistant", "content": reply})
+
+                except Exception as tool_err:
+                    err_msg = str(tool_err)
+                    if "402" in err_msg:
+                        render_error("Insufficient credits. Run `systemr pay` to add credits.")
+                    elif "401" in err_msg or "403" in err_msg:
+                        render_error("Auth required. Run `systemr configure --api-key`.")
+                    else:
+                        render_error(f"Tool failed: {err_msg[:80]}")
+                    reply = ""
+
+                continue  # Skip chat stream — tool handled it
+
+            # Compact if over threshold
+            if len(messages) > COMPACTION_THRESHOLD:
+                messages = _compact_history(messages)
+                logger.info("context_compacted", messages=len(messages))
+
+            # Build request with profile + rules + standing orders + daily context
+            # Only send model if user explicitly chose one (via --model or /model)
+            # Backend handles default model selection via REASONING_MODEL env var
+            effective_model = current_model  # None = let backend decide
+            rules_text = load_rules() or ""
+            standing = load_standing_orders()
+            if standing and standing not in rules_text:
+                rules_text = rules_text + "\n\n" + standing if rules_text else standing
+            request = ChatRequest(
+                user_input=user_input,
+                session_id=str(db_session_id),
+                model=effective_model,
+                history=messages,
+                profile=load_profile() or None,
+                rules=rules_text or None,
+                daily_context=load_daily_context() or None,
+                research_mode=research,
             )
-        finally:
-            tui.exit()
+
             try:
-                await tui_task
-            except Exception:
-                pass
+                reply = loop.run_until_complete(
+                    _do_chat(request, token.access_token, credits)
+                )
+            except Exception as exc:
+                # On failure, retry once with no model override (let backend decide)
+                if effective_model:
+                    logger.info("model_failover_retry", from_model=effective_model)
+                    request.model = None
+                    try:
+                        reply = loop.run_until_complete(
+                            _do_chat(request, token.access_token, credits)
+                        )
+                    except Exception as exc2:
+                        render_error("Something went wrong. Try again or run `systemr doctor`.")
+                        logger.error("chat_failover_error", error=str(exc2))
+                        fire_hook(HookEvent.ERROR, context={"message": str(exc2)})
+                        reply = ""
+                else:
+                    render_error("Something went wrong. Try again or run `systemr doctor`.")
+                    logger.error("chat_error", error=str(exc))
+                    fire_hook(HookEvent.ERROR, context={"message": str(exc)})
+                    reply = ""
+
+            if reply:
+                store.add_chat_message(db_session_id, "assistant", reply)
+                messages.append({"role": "assistant", "content": reply})
 
-    try:
-        asyncio.run(_run())
-    except (KeyboardInterrupt, EOFError):
-        pass
     finally:
+        loop.close()
         _save_session(db_session_id, messages)
         fire_hook(HookEvent.POST_SESSION, context=credits.summary())
         logger.info("session_ended", **credits.summary())
 
-        # Show session summary
+        # Show session summary if there was activity
         if credits.messages_sent > 0:
             console.print()
             console.print(f"  [{GRAY}]Session summary[/]")
             s = credits.summary()
-            console.print(f"    [{WHITE}]{s['credits_used']:.1f}[/] [{DIM}]credits[/]   "
+            console.print(f"    [{WHITE}]{s['credits_used']:.1f}[/] [{DIM}]credits[/]   "  # type: ignore[str-format]
                           f"[{WHITE}]{s['tools_called']}[/] [{DIM}]tools[/]   "
                           f"[{WHITE}]{s['duration_min']}m[/] [{DIM}]duration[/]")
             console.print()

{systemr_cli-2.1.1 → systemr_cli-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "systemr-cli"
-version = "2.1.1"
+version = "2.2.0"
 description = "System R AI — trading operating system for agents"
 readme = "README.md"
 license = "MIT"

systemr_cli-2.1.1/neo/chat_runner.py

@@ -1,302 +0,0 @@
-"""Chat runner — TUI-based chat loop with fixed layout.
-
-Manages the full-screen TUI application while processing
-chat events (streaming, tools, confirmations) in the background.
-The TUI stays responsive during all operations.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import time
-from typing import Any
-
-import structlog
-
-from neo.credits import SessionCredits
-from neo.hooks import HookEvent, fire_hook
-from neo.profile import (
-    append_daily_log,
-    auto_save_rule_violation,
-    load_daily_context,
-    load_profile,
-    load_rules,
-    load_standing_orders,
-    profile_exists,
-    search_memory,
-)
-from neo.streaming import (
-    ChatRequest,
-    call_tool,
-    chat_blocking,
-    send_confirmation,
-    stream_chat,
-)
-from neo.tool_router import match_tool
-from neo.tui import ChatTUI
-
-logger = structlog.get_logger(module="chat_runner")
-
-
-async def run_chat_tui(
-    tui: ChatTUI,
-    access_token: str,
-    credits: SessionCredits,
-    store: Any,
-    db_session_id: int,
-    messages: list[dict[str, str]],
-    model: str | None = None,
-    research: bool = False,
-) -> None:
-    """Run the chat loop inside the TUI.
-
-    Alternates between waiting for user input and processing
-    the response (streaming, tool calls, etc.). The TUI handles
-    all display.
-    """
-    from neo.commands.chat_commands import (
-        COMPACTION_THRESHOLD,
-        _compact_history,
-        _handle_slash_command,
-    )
-
-    current_model = model
-
-    while True:
-        user_input = await tui.wait_for_input()
-        if user_input is None:
-            break
-        if not user_input:
-            continue
-
-        # Slash commands
-        if user_input.startswith("/"):
-            if user_input.strip() in ("/q", "/exit", "/quit"):
-                break
-            if user_input.strip() == "/clear":
-                messages.clear()
-                tui.clear_conversation()
-                tui.add_line("#3ECF8E", "  ✓ Conversation cleared.")
-                continue
-            if user_input.strip() == "/help":
-                _show_help(tui)
-                continue
-            if user_input.strip() == "/credits":
-                s = credits.summary()
-                tui.add_line("#A1A1AA", f"\n  Credits: ${s['credits_used']:.3f} used  │  {s['tools_called']} tools  │  {s['duration_min']}m")
-                continue
-            if user_input.startswith("/remember "):
-                text = user_input[10:].strip()
-                if text:
-                    from neo.profile import auto_save_explicit
-                    auto_save_explicit(text)
-                    tui.add_line("#3ECF8E", f"  ✓ Saved to memory.")
-                continue
-            if user_input.startswith("/memory "):
-                query = user_input[8:].strip()
-                if query:
-                    results = search_memory(query)
-                    if results:
-                        for r in results[:5]:
-                            tui.add_line("#A1A1AA", f"  {r}")
-                    else:
-                        tui.add_line("#52525B", "  No memories found.")
-                continue
-            # Other slash commands: pass to backend as regular chat
-            tui.add_line("#52525B", f"  Unknown command. /help for available commands.")
-            continue
-
-        store.add_chat_message(db_session_id, "user", user_input)
-        messages.append({"role": "user", "content": user_input})
-
-        # Tool pre-routing
-        tool_match_result = match_tool(user_input)
-        if tool_match_result:
-            tui.add_tool_running(tool_match_result.tool_name)
-            try:
-                tool_result = await call_tool(
-                    tool_match_result.tool_name, tool_match_result.arguments
-                )
-                result_data = tool_result.get("result", {})
-                cost = tool_result.get("cost_usdc") or (
-                    result_data.get("cost_usdc", "") if isinstance(result_data, dict) else ""
-                )
-                tui.add_tool_done(
-                    tool_match_result.tool_name,
-                    f"${cost}" if cost else "",
-                )
-                if isinstance(result_data, dict):
-                    tui.add_text("", "\n")
-                    for k, v in result_data.items():
-                        if k == "cost_usdc":
-                            continue
-                        if v is not None and str(v).strip():
-                            tui.add_line("#A1A1AA", f"  {k}: ")
-                            tui.add_text("#F5F5F5", str(v))
-                    tui.add_text("", "\n")
-                credits.add_response(credits_used=cost, tools=1)
-                reply = f"Tool {tool_match_result.tool_name}: {str(result_data)[:200]}"
-                store.add_chat_message(db_session_id, "assistant", reply)
-                messages.append({"role": "assistant", "content": reply})
-            except Exception as e:
-                err = str(e)
-                if "402" in err:
-                    tui.add_tool_error(tool_match_result.tool_name, "insufficient credits")
-                elif "401" in err or "403" in err:
-                    tui.add_tool_error(tool_match_result.tool_name, "auth required")
-                else:
-                    tui.add_tool_error(tool_match_result.tool_name, err[:60])
-            continue
-
-        # Compact history
-        if len(messages) > COMPACTION_THRESHOLD:
-            messages = _compact_history(messages)
-
-        # Build chat request
-        rules_text = load_rules() or ""
-        standing = load_standing_orders()
-        if standing and standing not in rules_text:
-            rules_text = rules_text + "\n\n" + standing if rules_text else standing
-
-        request = ChatRequest(
-            user_input=user_input,
-            session_id=str(db_session_id),
-            model=current_model,
-            history=messages,
-            profile=load_profile() or None,
-            rules=rules_text or None,
-            daily_context=load_daily_context() or None,
-            research_mode=research,
-        )
-
-        # Stream response
-        reply = await _stream_to_tui(tui, request, access_token, credits)
-
-        if reply:
-            store.add_chat_message(db_session_id, "assistant", reply)
-            messages.append({"role": "assistant", "content": reply})
-
-
-async def _stream_to_tui(
-    tui: ChatTUI,
-    request: ChatRequest,
-    access_token: str,
-    credits: SessionCredits,
-) -> str:
-    """Stream chat response into the TUI."""
-    collected_text = ""
-    tool_count = 0
-    has_trade = False
-    streaming_started = False
-    start_time = time.time()
-
-    tui.set_processing(True)
-
-    try:
-        async for event in stream_chat(request, access_token):
-            if event.event == "thinking":
-                text = event.parsed.get("text", event.parsed.get("status", ""))
-                if text:
-                    tui.add_thinking(text[:70])
-
-            elif event.event == "action":
-                tool = event.parsed.get("action", event.parsed.get("tool", ""))
-                params = event.parsed.get("parameters", {})
-                tool_count += 1
-                if tool:
-                    fire_hook(HookEvent.BEFORE_TOOL_CALL, context={"tool": tool, "args": params})
-                    tui.add_tool_running(tool)
-                    if params:
-                        try:
-                            result = await call_tool(tool, params)
-                            data = result.get("result", {})
-                            cost = result.get("cost_usdc") or (data.get("cost_usdc", "") if isinstance(data, dict) else "")
-                            tui.add_tool_done(tool, f"${cost}" if cost else "")
-                            if isinstance(data, dict):
-                                tui.add_text("", "\n")
-                                for k, v in data.items():
-                                    if k == "cost_usdc":
-                                        continue
-                                    if v is not None and str(v).strip():
-                                        tui.add_text("#A1A1AA", f"  {k}: ")
-                                        tui.add_text("#F5F5F5", f"{v}\n")
-                        except Exception as e:
-                            tui.add_tool_error(tool, str(e)[:60])
-
-            elif event.event == "text_delta":
-                text = event.parsed.get("text", event.parsed.get("delta", ""))
-                if text and text != "null":
-                    if not streaming_started:
-                        tui.start_response()
-                        streaming_started = True
-                    tui.stream_text(text)
-                    collected_text += text
-
-            elif event.event == "done":
-                if streaming_started:
-                    elapsed = time.time() - start_time
-                    tui.end_response(elapsed)
-                elif not collected_text:
-                    full = event.parsed.get("response", event.parsed.get("content", ""))
-                    if full:
-                        collected_text = full
-                        tui.start_response()
-                        tui.stream_text(full)
-                        tui.end_response(time.time() - start_time)
-
-                credits_used = event.parsed.get("credits_used")
-                balance = event.parsed.get("balance")
-                credits.add_response(
-                    credits_used=credits_used, balance=balance,
-                    tools=tool_count, trade=has_trade,
-                )
-                if credits_used:
-                    try:
-                        tui.add_credits(float(credits_used))
-                    except (ValueError, TypeError):
-                        pass
-
-            elif event.event == "error":
-                raw = event.parsed.get("message", event.parsed.get("error", ""))
-                msg = str(raw)
-                if "Classification backend unavailable" in msg:
-                    msg = "AI model temporarily unavailable. Try again."
-                elif "AccessDeniedException" in msg:
-                    msg = "AI model access error."
-                elif len(msg) > 120:
-                    msg = msg[:120] + "..."
-                tui.add_error(msg)
-
-    except Exception as exc:
-        tui.add_error(f"Connection error: {str(exc)[:60]}")
-        logger.error("stream_error", error=str(exc))
-    finally:
-        tui.set_processing(False)
-
-    return collected_text
-
-
-def _show_help(tui: ChatTUI) -> None:
-    """Show help in the TUI."""
-    tui.add_text("", "\n")
-    tui.add_line("#3ECF8E", "  Chat")
-    tui.add_line("#52525B", "    /morning      Morning briefing")
-    tui.add_line("#52525B", "    /eod          End of day review")
-    tui.add_line("#52525B", "    /plan         Plan today's trades")
-    tui.add_line("#52525B", "    /portfolio    Open positions")
-    tui.add_line("#52525B", "    /risk         Risk dashboard")
-    tui.add_text("", "\n")
-    tui.add_line("#3ECF8E", "  Memory")
-    tui.add_line("#52525B", "    /remember     Save a memory")
-    tui.add_line("#52525B", "    /memory       Search memories")
-    tui.add_line("#52525B", "    /sessions     Recent sessions")
-    tui.add_text("", "\n")
-    tui.add_line("#3ECF8E", "  Settings")
-    tui.add_line("#52525B", "    /model        Show or switch model")
-    tui.add_line("#52525B", "    /permissions   Safety profile")
-    tui.add_line("#52525B", "    /credits      Credit usage")
-    tui.add_text("", "\n")
-    tui.add_line("#3ECF8E", "  Session")
-    tui.add_line("#52525B", "    /clear        Clear conversation")
-    tui.add_line("#52525B", "    /q            Exit")
-    tui.add_text("", "\n")

systemr_cli-2.1.1/neo/tui.py

@@ -1,394 +0,0 @@
-"""Terminal UI Application — fixed-layout chat interface.
-
-Full-screen prompt_toolkit Application with:
-- Scrollable conversation area (top) with auto-scroll
-- Fixed separator + input prompt (middle)
-- Fixed separator + live status bar (bottom)
-
-Keyboard shortcuts:
-- Enter: submit message
-- Ctrl+D / Ctrl+C: exit
-- Ctrl+L: clear conversation
-- Page Up/Down: scroll conversation
-- Up/Down: input history
-- Escape: cancel current input
-"""
-
-from __future__ import annotations
-
-import asyncio
-import time
-from typing import Any, Callable
-
-from prompt_toolkit import Application
-from prompt_toolkit.buffer import Buffer
-from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.layout import (
-    HSplit,
-    Window,
-    FormattedTextControl,
-    BufferControl,
-    ScrollablePane,
-)
-from prompt_toolkit.layout.layout import Layout
-from prompt_toolkit.layout.dimension import Dimension
-from prompt_toolkit.formatted_text import FormattedText
-from prompt_toolkit.history import FileHistory
-from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
-from prompt_toolkit.styles import Style
-
-# ── Colors (match theme.py) ──
-GREEN = "#3ECF8E"
-GREEN_DIM = "#34B87A"
-RED = "#EF4444"
-DIM = "#52525B"
-MUTED = "#3F3F46"
-GRAY = "#A1A1AA"
-WHITE = "#F5F5F5"
-AMBER = "#F59E0B"
-BG = "#09090B"
-BG_INPUT = "#111114"
-
-# ── Prompt toolkit style ──
-TUI_STYLE = Style.from_dict({
-    # Conversation area
-    "conversation": f"bg:{BG} {GRAY}",
-    # Input area
-    "input-prompt": f"bold {WHITE}",
-    # Separators
-    "separator": MUTED,
-    # Status bar
-    "status": f"bg:{BG_INPUT} {DIM}",
-    "status.green": GREEN,
-    "status.red": RED,
-    "status.dim": DIM,
-    "status.muted": MUTED,
-    # Auto-suggest
-    "auto-suggest": DIM,
-})
-
-
-class ChatTUI:
-    """Fixed-layout terminal chat interface.
-
-    Layout:
-        ┌──────────────────────────────────────┐
-        │ [Scrollable conversation]             │
-        │   ◐ Thinking...                       │
-        │   ┃ Streaming response...             │
-        │   ✓ tool_name  $0.003                 │
-        ├──────────────────────────────────────┤
-        │ ❯ user input                          │
-        ├──────────────────────────────────────┤
-        │ ● sonnet │ ○ broker │ /help  │ 2m 3s │
-        └──────────────────────────────────────┘
-    """
-
-    def __init__(
-        self,
-        model: str = "sonnet",
-        broker: str | None = None,
-        history_file: str = "",
-    ) -> None:
-        self._model = model
-        self._broker = broker
-        self._conversation_lines: list[tuple[str, str]] = []
-        self._running = True
-        self._input_ready = asyncio.Event()
-        self._last_input = ""
-        self._credits_used: float = 0.0
-        self._tools_called: int = 0
-        self._start_time = time.time()
-        self._processing = False
-
-        # Conversation display
-        self._conversation_control = FormattedTextControl(
-            text=self._get_conversation_text,
-            focusable=False,
-        )
-
-        # Scrollable conversation window
-        self._conversation_window = Window(
-            content=self._conversation_control,
-            wrap_lines=True,
-        )
-
-        # Input buffer
-        self._input_buffer = Buffer(
-            name="input",
-            history=FileHistory(history_file) if history_file else None,
-            auto_suggest=AutoSuggestFromHistory(),
-            accept_handler=self._on_accept,
-            multiline=False,
-        )
-
-        # Separator
-        self._sep_control = FormattedTextControl(
-            text=lambda: FormattedText([(MUTED, "─" * 300)]),
-            focusable=False,
-        )
-
-        # Status bar
-        self._status_control = FormattedTextControl(
-            text=self._get_status_text,
-            focusable=False,
-        )
-
-        # Key bindings
-        kb = KeyBindings()
-
-        @kb.add("c-d")
-        def _exit(event: Any) -> None:
-            self._running = False
-            self._input_ready.set()
-            event.app.exit(result=None)
-
-        @kb.add("c-c")
-        def _interrupt(event: Any) -> None:
-            if self._processing:
-                # During processing: just signal (future: cancel stream)
-                pass
-            else:
-                self._running = False
-                self._input_ready.set()
-                event.app.exit(result=None)
-
-        @kb.add("c-l")
-        def _clear_screen(event: Any) -> None:
-            self._conversation_lines.clear()
-            self._invalidate()
-
-        @kb.add("escape")
-        def _cancel_input(event: Any) -> None:
-            self._input_buffer.text = ""
-
-        # Layout
-        self._layout = Layout(
-            HSplit([
-                # Scrollable conversation (takes all available space)
-                ScrollablePane(
-                    self._conversation_window,
-                ),
-                # Top separator
-                Window(content=self._sep_control, height=1),
-                # Input line with ❯ prefix
-                Window(
-                    content=BufferControl(buffer=self._input_buffer),
-                    height=1,
-                    get_line_prefix=lambda lineno, wrap: FormattedText(
-                        [("bold " + WHITE, "  ❯ ")]
-                    ),
-                ),
-                # Bottom separator
-                Window(content=self._sep_control, height=1),
-                # Status bar
-                Window(content=self._status_control, height=1),
-            ]),
-            focused_element=self._input_buffer,
-        )
-
-        # Application
-        self._app: Application[str | None] = Application(
-            layout=self._layout,
-            key_bindings=kb,
-            full_screen=True,
-            mouse_support=True,
-            style=TUI_STYLE,
-        )
-
-    # ── Internal handlers ──
-
-    def _on_accept(self, buffer: Buffer) -> bool:
-        """Handle Enter press."""
-        text = buffer.text.strip()
-        if text:
-            # Echo user input in conversation
-            self._conversation_lines.append((WHITE, f"\n  ❯ {text}\n"))
-        self._last_input = text
-        self._input_ready.set()
-        return False
-
-    def _get_conversation_text(self) -> FormattedText:
-        """Render conversation area."""
-        if not self._conversation_lines:
-            return FormattedText([
-                (DIM, "\n"),
-                (DIM, "  Type your message below.\n"),
-                (DIM, "  /help for commands. Ctrl+D to exit.\n"),
-            ])
-        return FormattedText(self._conversation_lines)
-
-    def _get_status_text(self) -> FormattedText:
-        """Render status bar with live data."""
-        elapsed = int(time.time() - self._start_time)
-        mins, secs = divmod(elapsed, 60)
-        time_str = f"{mins}m {secs}s" if mins else f"{secs}s"
-
-        parts: list[tuple[str, str]] = [("", "  ")]
-
-        # Model
-        parts.append((GREEN, "● "))
-        parts.append((DIM, self._model))
-        parts.append((MUTED, "  │  "))
-
-        # Broker
-        if self._broker:
-            parts.append((GREEN, "● "))
-            parts.append((DIM, self._broker))
-        else:
-            parts.append((RED, "○ "))
-            parts.append((DIM, "no broker"))
-        parts.append((MUTED, "  │  "))
-
-        # Stats
-        if self._tools_called > 0:
-            parts.append((DIM, f"{self._tools_called} tools"))
-            parts.append((MUTED, "  │  "))
-
-        if self._credits_used > 0:
-            parts.append((DIM, f"${self._credits_used:.3f}"))
-            parts.append((MUTED, "  │  "))
-
-        # Timer
-        parts.append((DIM, time_str))
-        parts.append((MUTED, "  │  "))
-
-        # Help hint
-        parts.append((DIM, "/help"))
-
-        return FormattedText(parts)
-
-    # ── Public API ──
-
-    def add_line(self, style: str, text: str) -> None:
-        """Add a line to conversation."""
-        self._conversation_lines.append((style, text + "\n"))
-        self._scroll_to_bottom()
-
-    def add_text(self, style: str, text: str) -> None:
-        """Add inline text (no newline) for streaming."""
-        self._conversation_lines.append((style, text))
-        self._scroll_to_bottom()
-
-    def add_thinking(self, text: str) -> None:
-        """Show thinking status. Replaces previous thinking line."""
-        # Remove previous thinking line if exists
-        if (self._conversation_lines and
-                self._conversation_lines[-1][1].startswith("  ◐")):
-            self._conversation_lines.pop()
-        self._conversation_lines.append((DIM, f"  ◐ {text}\n"))
-        self._scroll_to_bottom()
-
-    def clear_thinking(self) -> None:
-        """Remove the current thinking line."""
-        if (self._conversation_lines and
-                self._conversation_lines[-1][1].strip().startswith("◐")):
-            self._conversation_lines.pop()
-            self._invalidate()
-
-    def add_tool_running(self, name: str) -> None:
-        """Show tool starting."""
-        self.clear_thinking()
-        self.add_line(DIM, f"  ◐ {name}...")
-
-    def add_tool_done(self, name: str, cost: str = "") -> None:
-        """Show tool completed."""
-        # Replace running line
-        if (self._conversation_lines and
-                "◐" in self._conversation_lines[-1][1]):
-            self._conversation_lines.pop()
-        suffix = f"  {cost}" if cost else ""
-        self.add_line(GREEN, f"  ✓ {name}{suffix}")
-        self._tools_called += 1
-
-    def add_tool_error(self, name: str, error: str = "") -> None:
-        """Show tool error."""
-        if (self._conversation_lines and
-                "◐" in self._conversation_lines[-1][1]):
-            self._conversation_lines.pop()
-        suffix = f"  {error}" if error else ""
-        self.add_line(RED, f"  ✗ {name}{suffix}")
-
-    def add_error(self, msg: str) -> None:
-        """Show error message."""
-        self.clear_thinking()
-        self.add_line(RED, f"  ✗ {msg}")
-
-    def start_response(self) -> None:
-        """Start a new response block with green border."""
-        self.clear_thinking()
-        self.add_text(GREEN, "\n  ┃ ")
-
-    def stream_text(self, text: str) -> None:
-        """Stream text within a response block, char by char."""
-        for ch in text:
-            if ch == "\n":
-                self._conversation_lines.append((GREEN, "\n  ┃ "))
-            else:
-                self._conversation_lines.append(("", ch))
-        self._scroll_to_bottom()
-
-    def end_response(self, elapsed: float) -> None:
-        """End response block with timing."""
-        self.add_text(GREEN, "\n  ┃")
-        self.add_line(DIM, f"\n  ✦ {elapsed:.1f}s")
-        self.add_text("", "\n")
-
-    def add_credits(self, amount: float) -> None:
-        """Track credits used (updates status bar)."""
-        self._credits_used += amount
-        self._invalidate()
-
-    def set_model(self, model: str) -> None:
-        """Update model in status bar."""
-        self._model = model
-        self._invalidate()
-
-    def set_broker(self, broker: str | None) -> None:
-        """Update broker in status bar."""
-        self._broker = broker
-        self._invalidate()
-
-    def set_processing(self, active: bool) -> None:
-        """Set processing state (affects Ctrl+C behavior)."""
-        self._processing = active
-        self._invalidate()
-
-    def clear_conversation(self) -> None:
-        """Clear conversation area."""
-        self._conversation_lines.clear()
-        self._invalidate()
-
-    def _scroll_to_bottom(self) -> None:
-        """Scroll conversation to bottom and redraw."""
-        self._invalidate()
-
-    def _invalidate(self) -> None:
-        """Request UI redraw."""
-        if self._app and self._app.is_running:
-            self._app.invalidate()
-
-    async def wait_for_input(self) -> str | None:
-        """Wait for user to submit input. Returns None on exit."""
-        self._input_ready.clear()
-        self._input_buffer.text = ""
-        self._processing = False
-        self._invalidate()
-
-        await self._input_ready.wait()
-
-        if not self._running:
-            return None
-        self._processing = True
-        return self._last_input
-
-    async def run_async(self) -> None:
-        """Start the TUI application."""
-        await self._app.run_async()
-
-    def exit(self) -> None:
-        """Exit the application."""
-        self._running = False
-        self._input_ready.set()
-        if self._app.is_running:
-            self._app.exit()