deepy-cli 0.2.2__tar.gz → 0.2.3__tar.gz

{deepy_cli-0.2.2 → deepy_cli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deepy-cli
-Version: 0.2.2
+Version: 0.2.3
 Summary: Deepy - Vibe coding for DeepSeek models in your terminal
 Keywords: deepseek,coding-agent,terminal,cli,agents
 Author: kirineko

{deepy_cli-0.2.2 → deepy_cli-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepy-cli"
-version = "0.2.2"
+version = "0.2.3"
 description = "Deepy - Vibe coding for DeepSeek models in your terminal"
 readme = "README.md"
 authors = [

{deepy_cli-0.2.2 → deepy_cli-0.2.3}/src/deepy/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 
 
 def main() -> None:

{deepy_cli-0.2.2 → deepy_cli-0.2.3}/src/deepy/ui/prompt_input.py

@@ -16,6 +16,7 @@ from deepy.skills import SkillInfo
 from deepy.ui.file_mentions import FileMentionCompleter
 from deepy.ui.prompt_buffer import PromptBufferState
 from deepy.ui.slash_commands import SlashCommandItem
+from deepy.ui.status_footer import StatusFooter
 from deepy.ui.styles import DARK_PALETTE, UiPalette
 
 
@@ -23,7 +24,7 @@ DEFAULT_PROMPT_HISTORY = Path.home() / ".deepy" / "prompt-history.txt"
 CTRL_D_EXIT_CONFIRM_SIGNAL = "\0deepy:ctrl-d-exit-confirm\0"
 PROMPT_TOOLBAR_BACKGROUND = "#161821"
 PROMPT_TOOLBAR_FOREGROUND = "#a6adc8"
-PROMPT_TOOLBAR_HELP = "Ctrl+J newline · Ctrl+D twice exit"
+PROMPT_TOOLBAR_HELP = "newline: ctrl+j"
 PROMPT_MESSAGE: StyleAndTextTuples = [("class:prompt", "> ")]
 PROMPT_PLACEHOLDER: StyleAndTextTuples = [("class:placeholder", "Type your message...")]
 PROMPT_TOOLBAR: StyleAndTextTuples = [("class:toolbar.help", PROMPT_TOOLBAR_HELP)]
@@ -123,31 +124,34 @@ def prompt_for_input(
 
 
 def build_prompt_toolbar(
-    context_status: str = "",
+    context_status: str | StatusFooter = "",
     *,
     platform_name: str | None = None,
 ) -> AnyFormattedText:
+    if isinstance(context_status, StatusFooter):
+        return context_status.to_prompt_toolkit(help_text=PROMPT_TOOLBAR_HELP)
     if not context_status:
         return prompt_toolbar(platform_name)
-    toolbar: StyleAndTextTuples = [
-        ("class:toolbar.context", context_status),
-        ("class:toolbar.separator", " · "),
-        *prompt_toolbar(platform_name),
-    ]
-    return toolbar
+    return [("class:toolbar.context", context_status)]
 
 
 def prompt_style(palette: UiPalette | None = None) -> Style:
     palette = palette or DARK_PALETTE
+    toolbar_base = f"noreverse bg:{palette.toolbar_background}"
     return Style.from_dict(
         {
             "prompt": palette.prompt,
             "placeholder": palette.placeholder,
-            "toolbar": f"bg:{palette.toolbar_background} {palette.toolbar_foreground}",
-            "toolbar.context": f"bg:{palette.toolbar_background} {palette.toolbar_context}",
-            "toolbar.separator": f"bg:{palette.toolbar_background} {palette.toolbar_separator}",
-            "toolbar.help": f"bg:{palette.toolbar_background} {palette.toolbar_foreground}",
-            "bottom-toolbar": f"bg:{palette.toolbar_background} {palette.toolbar_foreground}",
+            "toolbar": f"{toolbar_base} {palette.toolbar_foreground}",
+            "toolbar.context": f"{toolbar_base} {palette.toolbar_context}",
+            "toolbar.separator": f"{toolbar_base} {palette.toolbar_separator}",
+            "toolbar.help": f"{toolbar_base} {palette.toolbar_metadata}",
+            "toolbar.title": f"{toolbar_base} {palette.toolbar_identity}",
+            "toolbar.identity": f"{toolbar_base} {palette.toolbar_identity}",
+            "toolbar.active": f"{toolbar_base} {palette.toolbar_active}",
+            "toolbar.loaded": f"{toolbar_base} {palette.toolbar_loaded}",
+            "toolbar.metadata": f"{toolbar_base} {palette.toolbar_metadata}",
+            "bottom-toolbar": f"{toolbar_base} {palette.toolbar_foreground}",
         }
     )
 

deepy_cli-0.2.3/src/deepy/ui/status_footer.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+from prompt_toolkit.formatted_text import StyleAndTextTuples
+from rich.text import Text
+
+from deepy.ui.styles import DARK_PALETTE, UiPalette
+
+
+FooterSegmentRole = Literal["identity", "active", "loaded", "metadata", "context"]
+FooterPartRole = Literal["title", "loaded", "active", "metadata", "context"]
+
+
+@dataclass(frozen=True)
+class StatusFooterSegment:
+    text: str
+    role: FooterSegmentRole = "metadata"
+
+
+@dataclass(frozen=True)
+class StatusFooter:
+    segments: tuple[StatusFooterSegment, ...]
+
+    @property
+    def plain(self) -> str:
+        return " · ".join(segment.text for segment in self.segments if segment.text)
+
+    def with_active(self, active_work: str | None) -> "StatusFooter":
+        active = (active_work or "").strip()
+        if not active:
+            return self
+        segments = [segment for segment in self.segments if segment.role != "active"]
+        insert_at = 1 if segments else 0
+        segments.insert(insert_at, StatusFooterSegment(active, "active"))
+        return StatusFooter(tuple(segments))
+
+    def to_prompt_toolkit(self, *, help_text: str = "") -> StyleAndTextTuples:
+        toolbar: StyleAndTextTuples = []
+        for index, segment in enumerate(segment for segment in self.segments if segment.text):
+            if index:
+                toolbar.append(("class:toolbar.separator", " · "))
+            for role, text in _segment_parts(segment):
+                toolbar.append((f"class:toolbar.{role}", text))
+        if help_text:
+            if toolbar:
+                toolbar.append(("class:toolbar.separator", " · "))
+            for role, text in _help_parts(help_text):
+                toolbar.append((f"class:toolbar.{role}", text))
+        return toolbar
+
+    def to_rich_text(self, palette: UiPalette | None = None) -> Text:
+        palette = palette or DARK_PALETTE
+        text = Text()
+        for index, segment in enumerate(segment for segment in self.segments if segment.text):
+            if index:
+                text.append(" · ", style=palette.toolbar_separator)
+            for role, value in _segment_parts(segment):
+                text.append(value, style=_rich_style_for_role(role, palette))
+        return text
+
+    def __str__(self) -> str:
+        return self.plain
+
+
+def _segment_parts(segment: StatusFooterSegment) -> list[tuple[FooterPartRole, str]]:
+    if segment.role == "loaded" and segment.text.startswith("[") and segment.text.endswith("]"):
+        return [("loaded", segment.text)]
+    title = _known_title(segment.text)
+    if title is None:
+        return [(_part_role_for_segment(segment.role), segment.text)]
+    rest = segment.text[len(title) :]
+    role = "context" if segment.role == "context" else "metadata"
+    return [("title", title), (role, rest)]
+
+
+def _help_parts(help_text: str) -> list[tuple[FooterPartRole, str]]:
+    title = _known_title(help_text)
+    if title is None:
+        return [("metadata", help_text)]
+    return [("title", title), ("metadata", help_text[len(title) :])]
+
+
+def _known_title(text: str) -> str | None:
+    for title in ("model", "cwd", "mcp", "ctx", "newline"):
+        if text == title or text.startswith(f"{title} ") or text.startswith(f"{title}:"):
+            return title
+    return None
+
+
+def _part_role_for_segment(role: FooterSegmentRole) -> FooterPartRole:
+    if role == "active":
+        return "active"
+    if role == "loaded":
+        return "loaded"
+    if role == "context":
+        return "context"
+    return "metadata"
+
+
+def _rich_style_for_role(role: FooterPartRole, palette: UiPalette) -> str:
+    if role == "title":
+        return _rich_style(palette.toolbar_identity)
+    if role == "loaded":
+        return _rich_style(palette.toolbar_loaded)
+    if role == "active":
+        return _rich_style(palette.toolbar_active)
+    if role == "context":
+        return _rich_style(palette.toolbar_context)
+    return _rich_style(palette.toolbar_metadata)
+
+
+def _rich_style(style: str) -> str:
+    if style.endswith(" bold"):
+        return f"bold {style.removesuffix(' bold')}"
+    return style

{deepy_cli-0.2.2 → deepy_cli-0.2.3}/src/deepy/ui/styles.py

@@ -43,6 +43,10 @@ class UiPalette:
     toolbar_foreground: str
     toolbar_context: str
     toolbar_separator: str
+    toolbar_identity: str
+    toolbar_active: str
+    toolbar_loaded: str
+    toolbar_metadata: str
     markdown_heading: str
     markdown_subheading: str
     markdown_bullet: str
@@ -78,9 +82,13 @@ DARK_PALETTE = UiPalette(
     prompt="ansicyan bold",
     placeholder="#8a90aa",
     toolbar_background="#161821",
-    toolbar_foreground="#a6adc8",
-    toolbar_context="#a6adc8",
+    toolbar_foreground="#b7bdd4",
+    toolbar_context="#b7bdd4",
     toolbar_separator="#4b5068",
+    toolbar_identity="bold #b7bdd4",
+    toolbar_active="bold #b7bdd4",
+    toolbar_loaded="bold #b7bdd4",
+    toolbar_metadata="#b7bdd4",
     markdown_heading="bold bright_cyan",
     markdown_subheading="bold cyan",
     markdown_bullet="bright_blue",
@@ -115,10 +123,14 @@ LIGHT_PALETTE = UiPalette(
     diff_context="#374151",
     prompt="#0369a1 bold",
     placeholder="#64748b",
-    toolbar_background="#e2e8f0",
-    toolbar_foreground="#0f172a",
-    toolbar_context="#047857 bold",
-    toolbar_separator="#64748b",
+    toolbar_background="#d8d8f2",
+    toolbar_foreground="#334155",
+    toolbar_context="#334155",
+    toolbar_separator="#94a3b8",
+    toolbar_identity="bold #334155",
+    toolbar_active="bold #334155",
+    toolbar_loaded="bold #334155",
+    toolbar_metadata="#334155",
     markdown_heading="bold #0f766e",
     markdown_subheading="bold #0369a1",
     markdown_bullet="#2563eb",

{deepy_cli-0.2.2 → deepy_cli-0.2.3}/src/deepy/ui/terminal.py

@@ -67,7 +67,6 @@ from deepy.ui.local_command import (
     shell_tool_result_json,
 )
 from deepy.ui.message_view import (
-    build_thinking_summary,
     format_tool_display_label,
     format_tool_call_summary,
     format_tool_progress_summary,
@@ -91,6 +90,7 @@ from deepy.ui.skill_picker import (
     show_skill_detail_view,
 )
 from deepy.ui.slash_commands import build_slash_commands
+from deepy.ui.status_footer import StatusFooter, StatusFooterSegment
 from deepy.ui.styles import (
     DARK_PALETTE,
     UiPalette,
@@ -167,7 +167,7 @@ def run_interactive(
 
     loaded_skill_names: list[str] = []
     ctrl_d_exit_pending = False
-    context_status = _format_context_footer(
+    context_footer = _build_status_footer(
         session_id,
         project_root=root,
         settings=settings,
@@ -176,7 +176,7 @@ def run_interactive(
     async_runner = asyncio.Runner()
     mcp_runtime = DeepyMcpRuntime(settings, project_root=root)
     async_runner.run(mcp_runtime.connect())
-    context_status = _format_context_footer(
+    context_footer = _build_status_footer(
         session_id,
         project_root=root,
         settings=settings,
@@ -202,7 +202,7 @@ def run_interactive(
             try:
                 text = prompt_for_input(
                     prompt_session,
-                    bottom_toolbar=build_prompt_toolbar(context_status),
+                    bottom_toolbar=build_prompt_toolbar(context_footer),
                 )
             except EOFError:
                 if ctrl_d_exit_pending:
@@ -236,8 +236,9 @@ def run_interactive(
                     session_id,
                     settings=settings,
                     palette=palette,
+                    mcp_runtime=mcp_runtime,
                 )
-                context_status = _format_context_footer(
+                context_footer = _build_status_footer(
                     session_id,
                     project_root=root,
                     settings=settings,
@@ -295,7 +296,7 @@ def run_interactive(
                         session_id = summary.session_id
                     _print_assistant_output(output, summary.output, palette=palette)
                     _print_usage_footer(output, summary, settings=settings, project_root=root, palette=palette)
-                    context_status = _format_context_footer(
+                    context_footer = _build_status_footer(
                         summary.session_id,
                         project_root=root,
                         settings=settings,
@@ -319,7 +320,7 @@ def run_interactive(
                     session_id = summary.session_id
                     _print_assistant_output(output, summary.output, palette=palette)
                     _print_usage_footer(output, summary, settings=settings, project_root=root, palette=palette)
-                    context_status = _format_context_footer(
+                    context_footer = _build_status_footer(
                         summary.session_id,
                         project_root=root,
                         settings=settings,
@@ -344,8 +345,8 @@ def run_interactive(
                 if slash.name in {"skills", "theme", "reset", "model"}:
                     prompt_session = _create_interactive_prompt_session(root, palette, loaded_skill_names)
                 session_id = next_session
-                if slash.name in {"new", "resume", "reset", "model", "compact"}:
-                    context_status = _format_context_footer(
+                if slash.name in {"new", "resume", "reset", "model", "compact", "skills", "theme", "mcp"}:
+                    context_footer = _build_status_footer(
                         session_id,
                         project_root=root,
                         settings=settings,
@@ -394,7 +395,7 @@ def run_interactive(
                 session_id = summary.session_id
             _print_assistant_output(output, summary.output, palette=palette)
             _print_usage_footer(output, summary, settings=settings, project_root=root, palette=palette)
-            context_status = _format_context_footer(
+            context_footer = _build_status_footer(
                 summary.session_id,
                 project_root=root,
                 settings=settings,
@@ -465,6 +466,13 @@ def _run_once_with_status(
     original_should_interrupt = kwargs.pop("should_interrupt", None)
     project_root = kwargs.get("project_root")
     project_root_text = str(project_root) if project_root is not None else None
+    settings = kwargs.get("settings")
+    footer = _build_status_footer(
+        kwargs.get("session_id"),
+        project_root=project_root if isinstance(project_root, Path) else None,
+        settings=settings if isinstance(settings, Settings) else None,
+        mcp_runtime=kwargs.get("mcp_runtime"),
+    )
     renderer: TerminalStreamRenderer | None = None
     started_at = time.monotonic()
     interrupt_requested = threading.Event()
@@ -479,13 +487,19 @@ def _run_once_with_status(
     kwargs["should_interrupt"] = should_interrupt
 
     active_palette = palette if isinstance(palette, UiPalette) else DARK_PALETTE
-    with console.status(_working_status_text(started_at, palette=active_palette), spinner="dots") as status:
+    with _status_display(
+        console,
+        _working_status_text(started_at, palette=active_palette, footer=footer),
+        footer.to_rich_text(active_palette) if footer.segments else None,
+        palette=active_palette,
+    ) as status:
         renderer = TerminalStreamRenderer(
             console,
             project_root=project_root_text,
             status=status,
             status_started_at=started_at,
             palette=active_palette,
+            footer=footer,
         )
         stop_status_refresh = threading.Event()
         status_thread = threading.Thread(
@@ -523,6 +537,7 @@ def _handle_local_command(
     *,
     settings: Settings,
     palette: UiPalette | None = None,
+    mcp_runtime: DeepyMcpRuntime | None = None,
 ) -> str | None:
     palette = palette or resolve_ui_palette(settings.ui.theme)
     if not command_input.command:
@@ -532,9 +547,27 @@ def _handle_local_command(
     _print_user_input(console, command_input.raw_text, palette=palette)
     started_at = time.monotonic()
     interrupt_requested = threading.Event()
-    with console.status(
-        _local_command_status_text(command_input.command, started_at, palette=palette),
-        spinner="dots",
+    with _status_display(
+        console,
+        _local_command_status_text(
+            command_input.command,
+            started_at,
+            palette=palette,
+            footer=_build_status_footer(
+                current_session_id,
+                project_root=project_root,
+                settings=settings,
+                mcp_runtime=mcp_runtime,
+                active_work="running local command",
+            ),
+        ),
+        _build_status_footer(
+            current_session_id,
+            project_root=project_root,
+            settings=settings,
+            mcp_runtime=mcp_runtime,
+        ).to_rich_text(palette),
+        palette=palette,
     ):
         with _esc_interrupt_watcher(interrupt_requested):
             result = run_local_command(
@@ -666,11 +699,13 @@ class TerminalStreamRenderer:
         status: Any | None = None,
         status_started_at: float | None = None,
         palette: UiPalette | None = None,
+        footer: StatusFooter | None = None,
     ) -> None:
         self.console = console
         self.project_root = project_root
         self.status = status
         self.palette = palette or DARK_PALETTE
+        self.footer = footer
         self.status_started_at = (
             status_started_at if status_started_at is not None else time.monotonic()
         )
@@ -700,15 +735,14 @@ class TerminalStreamRenderer:
                 ),
             )
             self.reasoning_started = True
-        self.reasoning_buffer += text
-        self._print_stable_reasoning()
-        summary = build_thinking_summary(self.reasoning_buffer or text)
-        if self.status is not None and summary:
-            self.update_status(f"Thinking {summary}")
+        self.reasoning_buffer = "printed"
+        self.console.print(Text(text, style=self.palette.muted), end="")
+        if self.status is not None and self.status_detail != "thinking":
+            self.update_status("thinking")
 
     def set_tool_status(self, summary: str) -> None:
         if self.status is not None and summary:
-            self.update_status(f"Running {summary}")
+            self.update_status(f"tool {summary}")
 
     def update_status(self, detail: str | None = None) -> None:
         if detail is not None:
@@ -719,23 +753,16 @@ class TerminalStreamRenderer:
                     self.status_started_at,
                     self.status_detail,
                     palette=self.palette,
+                    footer=self.footer,
                 )
             )
 
     def flush(self) -> None:
-        self._print_stable_reasoning(force=True)
+        if self.reasoning_buffer:
+            self.console.print()
         self.reasoning_started = False
         self.reasoning_buffer = ""
 
-    def _print_stable_reasoning(self, *, force: bool = False) -> None:
-        text, self.reasoning_buffer = _split_stable_reasoning_text(
-            self.reasoning_buffer,
-            force=force,
-        )
-        if text:
-            self.console.print(Text(text.rstrip("\n"), style=self.palette.muted))
-
-
 def _handle_slash_command(
     command: SlashCommand,
     console: Console,
@@ -1856,32 +1883,55 @@ def _format_context_footer(
     settings: Settings | None = None,
     mcp_runtime: DeepyMcpRuntime | None = None,
 ) -> str:
+    return _build_status_footer(
+        session_id,
+        project_root=project_root,
+        settings=settings,
+        mcp_runtime=mcp_runtime,
+    ).plain
+
+
+def _build_status_footer(
+    session_id: str | None,
+    *,
+    project_root: Path | None = None,
+    settings: Settings | None = None,
+    mcp_runtime: DeepyMcpRuntime | None = None,
+    active_work: str | None = None,
+) -> StatusFooter:
     if settings is None:
-        return ""
+        return StatusFooter(())
 
-    parts = [
-        f"model {settings.model.name}",
-        f"thinking {settings.model.reasoning_mode}",
+    segments = [
+        StatusFooterSegment(
+            f"model {settings.model.name}[{settings.model.reasoning_mode}]",
+            "identity",
+        ),
     ]
     if project_root is not None:
-        parts.append(f"cwd {format_home_relative_path(project_root)}")
+        segments.append(StatusFooterSegment(f"cwd {format_home_relative_path(project_root)}", "metadata"))
         if has_agents_instructions(project_root):
-            parts.append("AGENTS.md loaded")
+            segments.append(StatusFooterSegment("[AGENTS.md]", "loaded"))
         if mcp_runtime is not None and mcp_runtime.active_servers:
-            parts.append(f"MCP {len(mcp_runtime.active_servers)} server(s)")
+            segments.append(StatusFooterSegment(f"mcp {len(mcp_runtime.active_servers)}", "loaded"))
     else:
-        parts.append("cwd unknown")
+        segments.append(StatusFooterSegment("cwd unknown", "metadata"))
 
     window_tokens = settings.context.window_tokens
     compact_threshold = settings.context.resolved_compact_threshold
     if window_tokens <= 0:
-        parts.append("context unknown")
-        return " · ".join(parts)
+        segments.append(StatusFooterSegment("ctx unknown", "context"))
+        return StatusFooter(tuple(segments)).with_active(active_work)
 
     session_entry = _session_entry(project_root, session_id)
-    parts.append(_format_context_window_status(session_entry, window_tokens, compact_threshold))
+    segments.append(
+        StatusFooterSegment(
+            _format_context_window_status(session_entry, window_tokens, compact_threshold),
+            "context",
+        )
+    )
 
-    return " · ".join(parts)
+    return StatusFooter(tuple(segments)).with_active(active_work)
 
 
 def _format_context_window_status(
@@ -1901,11 +1951,11 @@ def _format_context_window_status(
         )
         used_tokens = usage.used_tokens if usage is not None else None
     if used_tokens is None:
-        return f"ctx win unknown/{window_text}"
+        return f"ctx unknown/{window_text}"
     remaining_tokens = max(window_tokens - used_tokens, 0)
     percentage = used_tokens / window_tokens * 100
     status = (
-        f"ctx win {_format_token_count_short(used_tokens)}/{window_text} "
+        f"ctx {_format_token_count_short(used_tokens)}/{window_text} "
         f"({percentage:.1f}%, {_format_token_count_short(remaining_tokens)} left)"
     )
     if compact_threshold > 0 and used_tokens >= compact_threshold:
@@ -1947,18 +1997,209 @@ def _refresh_working_status(
     renderer: TerminalStreamRenderer,
     stop_event: threading.Event,
 ) -> None:
-    while not stop_event.wait(1):
+    while not stop_event.wait(0.2):
         renderer.update_status()
 
 
+@contextlib.contextmanager
+def _status_display(
+    console: Console,
+    initial_status: Text,
+    footer_status: Text | None = None,
+    *,
+    palette: UiPalette,
+):
+    if _should_use_bottom_status_overlay(console):
+        status = _TerminalBottomStatus(console, footer_status=footer_status, palette=palette)
+        status.start()
+        status.update(initial_status)
+        try:
+            yield status
+        finally:
+            status.clear()
+        return
+
+    yield _SilentStatus()
+
+
+def _should_use_bottom_status_overlay(console: Console) -> bool:
+    isatty = getattr(console.file, "isatty", None)
+    return bool(callable(isatty) and isatty())
+
+
+class _TerminalBottomStatus:
+    def __init__(
+        self,
+        console: Console,
+        *,
+        footer_status: Text | None,
+        palette: UiPalette,
+    ) -> None:
+        self.console = console
+        self.footer_status = footer_status
+        self.palette = palette
+        self.rows = 0
+        self.columns = 0
+
+    @property
+    def _reserved_lines(self) -> int:
+        return 2 if self.footer_status is not None else 1
+
+    def start(self) -> None:
+        self.columns, self.rows = shutil.get_terminal_size((80, 24))
+        if self.rows <= self._reserved_lines:
+            return
+        scroll_bottom = self.rows - self._reserved_lines
+        self.console.file.write(f"\x1b7\x1b[1;{scroll_bottom}r\x1b[{scroll_bottom};1H\x1b8")
+        self._write_footer()
+        self.console.file.flush()
+
+    def update(self, status: Text) -> None:
+        columns, rows = shutil.get_terminal_size((80, 24))
+        self.columns = columns
+        self.rows = rows
+        if rows <= self._reserved_lines:
+            return
+        runtime_row = rows - self._reserved_lines + 1
+        self._write_line(runtime_row, status.plain, _terminal_runtime_status_style(self.palette))
+        self._write_footer()
+        self.console.file.flush()
+
+    def clear(self) -> None:
+        columns, rows = shutil.get_terminal_size((80, 24))
+        self.columns = columns
+        self.rows = rows
+        if rows <= self._reserved_lines:
+            return
+        self.console.file.write("\x1b7\x1b[r")
+        for row in range(rows - self._reserved_lines + 1, rows + 1):
+            self.console.file.write(f"\x1b[{row};1H\x1b[2K")
+        self.console.file.write("\x1b8")
+        self.console.file.flush()
+
+    def _write_footer(self) -> None:
+        if self.footer_status is None or self.rows <= self._reserved_lines:
+            return
+        self._write_text_line(self.rows, self.footer_status)
+
+    def _write_line(self, row: int, text: str, style: str) -> None:
+        width = max(self.columns - 1, 1)
+        line = _truncate_status_line(text, max_width=width)
+        padded = line.ljust(width)
+        self.console.file.write(f"\x1b7\x1b[{row};1H\x1b[2K{style}{padded}\x1b[0m\x1b8")
+
+    def _write_text_line(self, row: int, text: Text) -> None:
+        width = max(self.columns - 1, 1)
+        plain = text.plain
+        truncated = len(plain) > width
+        body_width = max(width - 1, 0) if truncated else min(len(plain), width)
+        background = _hex_color(self.palette.toolbar_background)
+        default_style = _terminal_text_style(self.palette.toolbar_metadata, background=background)
+
+        self.console.file.write(f"\x1b7\x1b[{row};1H\x1b[2K")
+        cursor = 0
+        for span in sorted(text.spans, key=lambda item: item.start):
+            start = max(span.start, 0)
+            end = min(span.end, body_width)
+            if end <= cursor or start >= body_width:
+                continue
+            if start > cursor:
+                self.console.file.write(f"{default_style}{plain[cursor:start]}")
+            self.console.file.write(
+                f"{_terminal_text_style(str(span.style), background=background)}{plain[start:end]}"
+            )
+            cursor = end
+        if cursor < body_width:
+            self.console.file.write(f"{default_style}{plain[cursor:body_width]}")
+        if truncated and width > 0:
+            self.console.file.write(f"{default_style}…")
+        padding = width - len(_truncate_status_line(plain, max_width=width))
+        if padding > 0:
+            self.console.file.write(f"{default_style}{' ' * padding}")
+        self.console.file.write("\x1b[0m\x1b8")
+
+
+class _SilentStatus:
+    def update(self, status: Text) -> None:
+        return None
+
+
+def _terminal_status_style(palette: UiPalette) -> str:
+    return _terminal_footer_status_style(palette)
+
+
+def _terminal_footer_status_style(palette: UiPalette) -> str:
+    foreground = _hex_color(palette.toolbar_metadata)
+    background = _hex_color(palette.toolbar_background)
+    return _terminal_ansi_style(foreground=foreground, background=background)
+
+
+def _terminal_runtime_status_style(palette: UiPalette) -> str:
+    foreground = _hex_color(palette.toolbar_background) or "#161821"
+    background = _hex_color(palette.warning) or "#facc15"
+    return _terminal_ansi_style(foreground=foreground, background=background, bold=True)
+
+
+def _terminal_text_style(style: str, *, background: str = "") -> str:
+    parts = style.split()
+    foreground = _hex_color(style)
+    return _terminal_ansi_style(
+        foreground=foreground,
+        background=background,
+        bold="bold" in parts,
+    )
+
+
+def _terminal_ansi_style(
+    *,
+    foreground: str = "",
+    background: str = "",
+    bold: bool = False,
+) -> str:
+    codes: list[str] = []
+    codes.append("1" if bold else "22")
+    if foreground:
+        codes.append(_ansi_rgb("38", foreground))
+    if background:
+        codes.append(_ansi_rgb("48", background))
+    return f"\x1b[{';'.join(codes)}m" if codes else ""
+
+
+def _hex_color(style: str) -> str:
+    return next((part for part in style.split() if part.startswith("#") and len(part) == 7), "")
+
+
+def _ansi_rgb(prefix: str, color: str) -> str:
+    red = int(color[1:3], 16)
+    green = int(color[3:5], 16)
+    blue = int(color[5:7], 16)
+    return f"{prefix};2;{red};{green};{blue}"
+
+
+def _truncate_status_line(text: str, *, max_width: int) -> str:
+    if len(text) <= max_width:
+        return text
+    if max_width <= 1:
+        return text[:max_width]
+    return f"{text[: max_width - 1]}…"
+
+
 def _working_status_text(
     started_at: float,
     detail: str = "",
     *,
     palette: UiPalette | None = None,
+    footer: StatusFooter | None = None,
 ) -> Text:
     palette = palette or DARK_PALETTE
     elapsed = _format_duration_ms(int((time.monotonic() - started_at) * 1000)) or "0s"
+    if footer is not None and footer.segments:
+        return _runtime_status_text(
+            elapsed=elapsed,
+            detail=detail or "status working",
+            spinner=_runtime_spinner_frame(started_at),
+            palette=palette,
+        )
     text = Text.assemble(
         ("Working ", f"bold {palette.muted}"),
         (f"({elapsed} · esc to interrupt)", palette.muted),
@@ -1974,15 +2215,63 @@ def _local_command_status_text(
     started_at: float,
     *,
     palette: UiPalette | None = None,
+    footer: StatusFooter | None = None,
 ) -> Text:
     palette = palette or DARK_PALETTE
     elapsed = _format_duration_ms(int((time.monotonic() - started_at) * 1000)) or "0s"
-    return Text.assemble(
+    if footer is not None and footer.segments:
+        text = _runtime_status_text(
+            elapsed=elapsed,
+            detail="local command",
+            spinner=_runtime_spinner_frame(started_at),
+            palette=palette,
+        )
+        text.append(" · ", style=palette.toolbar_separator)
+        text.append(command, style=palette.toolbar_metadata)
+        return text
+    text = Text.assemble(
         ("Running local command ", f"bold {palette.muted}"),
         (f"({elapsed})", palette.muted),
-        (" · ", palette.muted),
-        (command, palette.muted),
     )
+    text.append(" · ", style=palette.muted)
+    text.append(command, style=palette.muted)
+    return text
+
+
+def _runtime_status_text(
+    *,
+    elapsed: str,
+    detail: str,
+    spinner: str = "",
+    palette: UiPalette,
+) -> Text:
+    parts: list[tuple[str, str]] = []
+    style = _runtime_text_style(palette)
+    if spinner:
+        parts.extend([(spinner, style), (" ", style)])
+    parts.extend(
+        [
+            ("time ", style),
+            (elapsed, style),
+            (" · ", style),
+            ("esc to interrupt", style),
+        ]
+    )
+    text = Text.assemble(*parts)
+    if detail:
+        text.append(" · ", style=style)
+        text.append(detail, style=style)
+    return text
+
+
+def _runtime_text_style(palette: UiPalette) -> str:
+    return f"bold {palette.toolbar_background}"
+
+
+def _runtime_spinner_frame(started_at: float) -> str:
+    frames = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+    index = int(max(0.0, time.monotonic() - started_at) * 10) % len(frames)
+    return frames[index]
 
 
 def _format_duration_ms(duration_ms: int) -> str:
@@ -2111,20 +2400,6 @@ def _format_tool_output_debug(output: str) -> str:
     return json_utils.dumps_pretty(parsed)
 
 
-_REASONING_BUFFER_TARGET_CHARS = 180
-
-
-def _split_stable_reasoning_text(text: str, *, force: bool = False) -> tuple[str, str]:
-    if force:
-        return text, ""
-    newline_index = text.rfind("\n")
-    if newline_index >= 0:
-        return text[: newline_index + 1], text[newline_index + 1 :]
-    if len(text) >= _REASONING_BUFFER_TARGET_CHARS:
-        return text, ""
-    return "", text
-
-
 def _status_line(text: str, style: str) -> Text:
     label_match = re.match(r"(\[[^\]]+\])(\s?.*)", text, flags=re.DOTALL)
     if label_match: