seedcode-cli 7.2.5__py3-none-any.whl → 8.2.5__py3-none-any.whl

seedcode/__init__.py

@@ -6,7 +6,7 @@ Plant ideas. Grow code.
 # Single source of truth for the application version. Every consumer reads it:
 # the PyPI build (via [tool.hatch.version]), the CLI --version flag, the
 # Windows installer metadata, the GitHub release tag, and the WinGet manifest.
-__version__ = "7.2.5"
+__version__ = "8.2.5"
 __author__ = "Al Shahriar Sowan"
 __publisher__ = "Eagox Studio"
 # Current author/company links, surfaced by /about and the README credits.

seedcode/app.py

@@ -45,7 +45,8 @@ from .ui import UI
 from .ui.badges import badge_for_status
 from .ui.menu import MenuItem, run_menu
 from .ui.reference import CONTROLS_HINT, INPUT_HINT
-from .ui.tasks import TaskFlow, TaskState
+from .ui.state import AppState, Status
+from .ui.tasks import TaskFlow, TaskState, activity_for
 from .ui.textbox import prompt_label
 from .ui.theme import pt_style, set_active_theme
 from .utils.logger import get_logger
@@ -149,35 +150,43 @@ def _key_status(config: AppConfig) -> str:
     return config.masked_key()
 
 
-def _mode_status(config: AppConfig) -> str:
-    """Menu status for the Code Mode item (ON only when really active)."""
+def _workspace_status(config: AppConfig) -> str:
+    """Menu status for the workspace capability (ON only when really active).
+
+    The workspace (`.seedcode` project memory + index) is a capability of Agent
+    Mode, not a separate mode, so its status reflects that session alone rather
+    than the mode name.
+    """
     try:
         from .codemode_state import codemode_state
 
-        if codemode_state().enabled:
-            return "ON"
+        return "ON" if codemode_state().enabled else "OFF"
     except Exception:
-        pass
-    return "ON" if config.agent_mode else "OFF"
+        return "OFF"
 
 
 def _main_menu(config: AppConfig):
     """The interactive main menu; returns an action id or None (exit).
 
-    v6.2.5 reference layout: the six mode/setup actions carry Ctrl+1..Ctrl+6
-    shortcuts that execute the real handlers (no decorative items), followed
-    by the chat/setup actions kept from earlier releases.
+    v8.2.5 layout: the mode/setup actions carry Ctrl+1..Ctrl+4 shortcuts that
+    execute the real handlers (no decorative items), followed by the
+    chat/setup actions kept from earlier releases. There are exactly two
+    modes — Chat and Agent — and Code Mode's workspace capability lives inside
+    Agent Mode.
     """
     provider = PROVIDERS.get(config.provider)
     badge = badge_for_status(provider.status if provider is not None else "")
     return run_menu(
         [
-            MenuItem("Code Mode", "codemode", status=_mode_status(config), shortcut="1"),
-            MenuItem("Agent Mode", "agent", shortcut="2"),
-            MenuItem("Assist Mode", "assist", shortcut="3"),
-            MenuItem("Project Memory", "memory", shortcut="4"),
-            MenuItem("Settings", "settings", shortcut="5"),
-            MenuItem("Exit", "exit", shortcut="6"),
+            MenuItem("Agent Mode", "agent", shortcut="1"),
+            MenuItem(
+                "Project Workspace",
+                "memory",
+                status=_workspace_status(config),
+                shortcut="2",
+            ),
+            MenuItem("Settings", "settings", shortcut="3"),
+            MenuItem("Exit", "exit", shortcut="4"),
             MenuItem("Start Chat", "chat", status=_model_status(config), badge=badge),
             MenuItem("Provider", "provider", status=_provider_status(config)),
             MenuItem("API Key", "apikey", status=_key_status(config)),
@@ -290,6 +299,20 @@ class _TaskPresenter:
         self._echo_lines = 0
         self._echo_elided = False
 
+    # --- live status (persistent TUI only) ----------------------------------
+    def _set_status(self, status: Status, operation: str | None = None) -> None:
+        """Reflect a real phase on the live header; a no-op on the plain UI.
+
+        Only the TUI exposes ``state``, so the sequential console is untouched.
+        """
+        state = getattr(self.ui, "state", None)
+        if state is None:
+            return
+        try:
+            state.set_status(status, operation)
+        except Exception:
+            pass  # a cosmetic status must never break a task
+
     # --- one command's live output ------------------------------------------
     def reset_echo(self) -> None:
         self._echo_lines = 0
@@ -297,6 +320,8 @@ class _TaskPresenter:
 
     def on_output(self, line: str) -> None:
         """Compact live echo: the first few lines, then a single elision note."""
+        if self._echo_lines == 0:
+            self._set_status(Status.EXECUTING, "running a command")
         if self._echo_lines < self.MAX_ECHO_LINES:
             self.ui.dim(f"  │ {line[:200]}")
         elif not self._echo_elided:
@@ -315,6 +340,7 @@ class _TaskPresenter:
             return
         if kind == "error":
             self.ui.dim(f"  ✖ {detail.splitlines()[0][:120]}")
+            self._set_status(Status.ERROR, "an operation failed")
         elif kind == "switching_provider":
             # A provider request failed and a healthy fallback took over; the
             # task continues rather than restarting (v7.2.5).
@@ -324,11 +350,12 @@ class _TaskPresenter:
         elif kind == "retry":
             self.ui.dim(f"  {detail}")
         elif kind == "limit":
-            self.ui.warning(f"Assist stopped: {detail}")
+            self.ui.warning(f"Agent Mode stopped: {detail}")
         elif kind == "call" and flow is None:
             # With a task view on screen the step list already shows the tool
             # work; without one, narrate it (the plain/legacy experience).
             self.ui.dim(f"  ⚒ {detail}")
+            self._set_status(Status.EXECUTING, detail)
 
     # --- structured activity -> step states ---------------------------------
     def on_step(self, payload: dict) -> None:
@@ -341,6 +368,7 @@ class _TaskPresenter:
         if phase == "tool_start":
             self.reset_echo()
             flow.observe_tool_start(name, args)
+            self._set_status(Status.EXECUTING, activity_for(name, args))
         elif phase == "tool_done":
             flow.observe_tool_done(
                 name,
@@ -348,6 +376,7 @@ class _TaskPresenter:
                 str(payload.get("output") or ""),
                 args,
             )
+            self._set_status(Status.WORKING, "continuing")
         elif phase == "say":
             flow.observe_text(str(payload.get("text") or ""))
 
@@ -364,6 +393,21 @@ class _TaskPresenter:
 
         flow = self.flow
         session = session_mod.current_session()
+        # Reflect the real session phase on the live header (TUI only).
+        phase = {
+            "plan": (Status.THINKING, "planning the work"),
+            "plan_ready": (Status.WORKING, "plan ready"),
+            "task_start": (Status.WORKING, detail),
+            "verify": (Status.WORKING, "verifying acceptance criteria"),
+            "recovery": (Status.WORKING, "diagnosing and repairing"),
+            "reconnect": (Status.THINKING, "reconnecting to the provider"),
+            "network_lost": (Status.ERROR, detail),
+            "final_verify": (Status.EXECUTING, "final verification"),
+            "task_blocked": (Status.ERROR, detail),
+            "task_failed": (Status.ERROR, detail),
+        }.get(kind)
+        if phase is not None:
+            self._set_status(*phase)
         if kind == "plan":
             self.ui.dim("  planning the work…")
             return
@@ -497,15 +541,10 @@ def agent_presenter(agent: AgentEngine) -> _TaskPresenter | None:
 
 
 def _task_mode_label(config: AppConfig) -> str:
-    """The mode named in a task header (Code Mode sharpens Assist Mode)."""
-    try:
-        from .codemode_state import codemode_state
+    """The mode named in a task header (Chat Mode / Agent Mode only)."""
+    from .core.modes import active_mode, mode_title
 
-        if codemode_state().enabled:
-            return "Code Mode"
-    except Exception:
-        pass
-    return "Assist Mode"
+    return mode_title(active_mode(config))
 
 
 def _save_codemode_summary(agent: AgentEngine, text: str, outcome: str) -> None:
@@ -560,7 +599,9 @@ def _handle_codemode(
 
     lc = lifecycle()
     workspace, store = _codemode_workspace()
-    flow = TaskFlow.for_ui(ui, mode_label="Code Mode", task=text)
+    config = getattr(agent, "config", None)
+    label = _task_mode_label(config) if config is not None else "Agent Mode"
+    flow = TaskFlow.for_ui(ui, mode_label=label, task=text)
     if presenter is not None:
         presenter.flow = flow
     if flow is not None:
@@ -681,7 +722,7 @@ def _handle_agent(
     text: str,
     presenter: _TaskPresenter | None = None,
 ) -> None:
-    """Run one full Assist/Code turn (tool loop) and render the final answer.
+    """Run one full Agent/Code turn (tool loop) and render the final answer.
 
     The turn is shown as a compact live task flow whose step states follow real
     engine activity (see :mod:`seedcode.ui.tasks`) — never a fake progress bar.
@@ -766,7 +807,7 @@ def _handle_agent(
 def _make_agent(
     ui: UI, config: AppConfig, presenter: "_TaskPresenter | None" = None
 ) -> AgentEngine:
-    """Build an Assist engine bound to the CWD and the configured permissions."""
+    """Build an Agent Mode engine bound to the CWD and configured permissions."""
     # Lazy import (matching _make_desktop_session): the optional, platform-
     # specific computer package stays out of app.py's top-level import graph.
     from .computer import is_available
@@ -818,7 +859,7 @@ def _make_desktop_session(ui: UI):
 
     The session is bound to the process-wide
     :class:`~seedcode.computer.SessionPermissionManager` so a permission the
-    user granted once at ``/assist on`` keeps holding even though this gate is
+    user granted once at ``/agent on`` keeps holding even though this gate is
     rebuilt whenever the permission level changes.
     """
     from .computer import DesktopGrant, DesktopSession, session_permissions
@@ -866,14 +907,14 @@ def _chat_loop(
 ) -> None:
     """Interactive chat until /exit (returns to the main menu).
 
-    Only an explicit exit leaves here: a finished task (Code Mode, Assist
-    Mode, Agent Mode or a plain chat turn) returns to the prompt with
+    Only an explicit exit leaves here: a finished task (Code Mode, Agent
+    Mode or a plain chat turn) returns to the prompt with
     ``Ready for next task.`` and the session keeps running.
     """
     ctx = CommandContext(ui=ui, config=config, engine=engine)
     ui.dim(INPUT_HINT)
 
-    # The Assist engine is built lazily on the first assist-mode turn and
+    # The Agent engine is built lazily on the first agent-mode turn and
     # rebuilt when the permission or desktop mode changes (its system
     # prompt and permission gates reflect both). The presenter that owns the
     # live step view lives for the whole chat session, so each turn can bind
@@ -1035,6 +1076,286 @@ def _build_chat_session(ui: UI) -> PromptSession:
     return PromptSession(key_bindings=kb)
 
 
+# ---------------------------------------------------------------------------
+# Persistent TUI session (v8.2.5)
+# ---------------------------------------------------------------------------
+
+
+def _terminal_size() -> tuple[int, int]:
+    """The real terminal size (80x24 when unknown, e.g. tests/CI)."""
+    import os
+
+    try:
+        size = os.get_terminal_size()
+        return max(20, int(size.columns)), max(6, int(size.lines))
+    except Exception:
+        return 80, 24
+
+
+class _TuiController:
+    """Drives the persistent session.
+
+    A message runs its turn on a worker thread while the prompt_toolkit
+    application keeps the screen, so the header stays fixed and output streams
+    into the middle region. Commands return control for one dispatch (a selector
+    or menu needs the terminal to itself), then the session resumes.
+    """
+
+    def __init__(self, ui, tui, config: AppConfig) -> None:
+        self.ui = ui
+        self.tui = tui
+        self.config = config
+        self.engine = ChatEngine(config, on_event=self._on_provider_event)
+        self.history = HistoryStore(provider_id=config.provider)
+        self.presenter = _TaskPresenter(ui)
+        self.ctx = CommandContext(ui=ui, config=config, engine=self.engine)
+        self.agent: AgentEngine | None = None
+        self.agent_perm = config.permission_mode
+        self.agent_codemode = _codemode_enabled()
+        self._backend = config.provider
+        tui.on_submit = self.submit
+        # Mode switches run in place: no application exit, no rebuild.
+        tui.on_command = self._inplace_command
+
+    # --- provider/backend --------------------------------------------------
+    def _on_provider_event(self, kind: str, detail: str) -> None:
+        if kind == "switching_provider":
+            self.ui.warning(f"Switching provider: {detail}")
+        elif kind == "retry":
+            self.ui.dim(f"  {detail}")
+
+    def _rebuild_backend(self) -> None:
+        """Rebuild the chat backend/history after a provider change."""
+        self.engine = ChatEngine(self.config, on_event=self._on_provider_event)
+        self.history = HistoryStore(provider_id=self.config.provider)
+        self.ctx = CommandContext(ui=self.ui, config=self.config, engine=self.engine)
+        self.agent = None
+        self._backend = self.config.provider
+
+    # --- one turn (worker thread) ------------------------------------------
+    def submit(self, text: str) -> None:
+        """Run one user turn to completion (never raises into the TUI)."""
+        from .core.modes import active_mode, agentic
+
+        with lifecycle().task_span():
+            if agentic(active_mode(self.config)):
+                self._ensure_agent()
+                _handle_agent(self.ui, self.agent, self.history, text, self.presenter)
+            else:
+                _handle_chat(self.ui, self.engine, self.history, text)
+        try:
+            self.tui.sync_from_config(self.config)
+        except Exception:
+            pass
+
+    def _inplace_command(self, text: str) -> None:
+        """Dispatch a mode-switch command without leaving the TUI.
+
+        The engine/agent are rebuilt only when the mode actually changed, and
+        the header is refreshed from live config — a pure state transition.
+        """
+        backend_before = self.config.provider
+        mode_before = self.config.mode
+        try:
+            dispatch(self.ctx, text)
+        except (KeyboardInterrupt, EOFError):
+            self.ui.dim("Cancelled.")
+        except Exception as exc:  # a broken command must not kill the session
+            _report_command_error(self.ui, exc)
+        if self.config.provider != backend_before:
+            self._rebuild_backend()
+        elif self.config.mode != mode_before:
+            # A mode change invalidates the agent built for the old mode.
+            self.agent = None
+        self.tui.sync_from_config(self.config)
+
+    def _ensure_agent(self) -> None:
+        codemode_now = _codemode_enabled()
+        if (
+            self.agent is None
+            or self.agent_perm != self.config.permission_mode
+            or self.agent_codemode != codemode_now
+        ):
+            self.agent = _make_agent(self.ui, self.config, self.presenter)
+            self.agent_perm = self.config.permission_mode
+            self.agent_codemode = codemode_now
+
+    # --- the session loop --------------------------------------------------
+    def run(self) -> None:
+        while True:
+            kind, payload = self.tui.run_once()
+            if kind == "exit":
+                self.tui.shutdown()
+                _exit_application(self.ui, "tui exit")
+                return
+            if kind == "key":
+                _run_key_action(
+                    self.ui, self.ctx, self.config, _KEY_ACTIONS.get(payload or "", "")
+                )
+                self.tui.sync_from_config(self.config)
+                continue
+            if kind == "toolbar":
+                # A header control was activated: run the real application
+                # action (the selector owns the terminal for one step).
+                self._toolbar_action(payload or "")
+                self.tui.sync_from_config(self.config)
+                continue
+            if kind != "command" or not payload:
+                continue
+            backend_before = self.config.provider
+            try:
+                result = dispatch(self.ctx, payload)
+            except (KeyboardInterrupt, EOFError):
+                self.ui.dim("Cancelled.")
+                continue
+            except Exception as exc:  # a broken command must not kill the session
+                parts = payload.split()
+                _log.exception("command failed: %s", parts[0] if parts else payload)
+                _report_command_error(self.ui, exc)
+                continue
+            if result.should_exit:
+                if self._menu():
+                    self.tui.shutdown()
+                    _exit_application(self.ui, "menu exit")
+                    return
+                continue
+            if self.config.provider != backend_before:
+                self._rebuild_backend()
+            self.tui.sync_from_config(self.config)
+
+    def _toolbar_action(self, action: str) -> None:
+        """Run a real action behind a header control (provider/model/mode).
+
+        The control is real UI, so the action is the same one the equivalent
+        slash command performs: provider/model open their selectors and mode
+        opens the three-way mode picker. A provider change rebuilds the chat
+        backend exactly as a mid-chat switch does.
+        """
+        try:
+            if action == "provider":
+                select_provider(self.ui, self.config)
+            elif action == "model":
+                select_model(self.ui, self.config)
+            elif action == "mode":
+                self._mode_menu()
+        except (KeyboardInterrupt, EOFError):
+            self.ui.dim("Cancelled.")
+        except Exception as exc:  # a control must never crash the session
+            _log.exception("toolbar action failed: %s", action)
+            _report_command_error(self.ui, exc)
+        if self.config.provider != self._backend:
+            self._rebuild_backend()
+
+    def _mode_menu(self) -> None:
+        """Mode picker for the header's Mode control (a real mode switch)."""
+        from .core.modes import Mode, active_mode
+
+        current = active_mode(self.config)
+        choice = run_menu(
+            [
+                MenuItem(
+                    "Chat", "chat", status="current" if current is Mode.CHAT else ""
+                ),
+                MenuItem(
+                    "Agent", "agent", status="current" if current is Mode.AGENT else ""
+                ),
+            ],
+            title="Mode",
+            hint="\u2191\u2193 move   Enter select   Esc cancel",
+        )
+        if choice:
+            self._command(f"/mode {choice}")
+
+    def _menu(self) -> bool:
+        """The interactive main menu; returns True when the user quits."""
+        while True:
+            if self.config.provider != self._backend:
+                self._rebuild_backend()
+            try:
+                choice = _main_menu(self.config)
+            except (KeyboardInterrupt, EOFError):
+                return True
+            if choice == "chat":
+                return False
+            try:
+                if choice == "provider":
+                    select_provider(self.ui, self.config)
+                elif choice == "apikey":
+                    apikey_menu(self.ui, self.config)
+                elif choice == "model":
+                    select_model(self.ui, self.config)
+                elif choice == "agent":
+                    self._command("/agent on")
+                elif choice == "memory":
+                    self._command("/codemode status")
+                elif choice == "settings":
+                    settings_menu(self.ui, self.config)
+                elif choice == "theme":
+                    pick_theme(self.ui, self.config)
+                elif choice == "about":
+                    show_about(self.ui, self.config)
+                elif choice in ("exit", None):
+                    return True
+            except (KeyboardInterrupt, EOFError):
+                self.ui.dim("Cancelled.")
+            except Exception as exc:  # menu actions must never crash the app
+                _log.exception("menu action failed: %s", choice)
+                _report_command_error(self.ui, exc)
+            self.tui.sync_from_config(self.config)
+
+    def _command(self, text: str) -> None:
+        try:
+            dispatch(self.ctx, text)
+        except Exception:
+            _log.exception("menu command failed: %s", text)
+
+
+def run_persistent(*, input_device=None, output_device=None) -> None:
+    """Start the persistent three-region TUI (interactive consoles only).
+
+    Guided setup runs *before* the TUI owns the screen, because its selectors
+    need the terminal to themselves and its output must be visible.
+    """
+    from .ui.tui import ChatTUI, TuiUI
+    from .utils.terminal_env import workspace_root
+
+    config = load_config()
+    sync_custom_providers(config)
+    set_active_theme(config.theme)
+
+    if not config.is_configured():
+        setup_ui = UI()
+        setup_ui.apply_theme(config.theme)
+        if not _guided_setup(setup_ui, config):
+            setup_ui.dim("Setup incomplete — a provider and a model are required.")
+            return
+
+    workspace = str(workspace_root())
+    columns, _rows = _terminal_size()
+    state = AppState.from_config(config, workspace=workspace)
+    tui = ChatTUI(
+        state,
+        workspace=workspace,
+        width=columns,
+        input_device=input_device,
+        output_device=output_device,
+    )
+    ui = TuiUI(tui)
+    ui.apply_theme(config.theme)
+    tui.banner_text()
+
+    # Best-effort teardown for the one legitimate shutdown path.
+    lifecycle().on_shutdown(_release_desktop_resources)
+
+    _log.info(
+        "persistent TUI started: provider=%s model=%s mode=%s",
+        config.provider,
+        config.model or "(none)",
+        getattr(config, "mode", "chat"),
+    )
+    _TuiController(ui, tui, config).run()
+
+
 def run(ui: UI) -> None:
     """Show the startup dashboard, drop straight into chat, then the menu.
 
@@ -1116,12 +1437,8 @@ def run(ui: UI) -> None:
                 apikey_menu(ui, config)
             elif choice == "model":
                 select_model(ui, config)
-            elif choice == "codemode":
-                _dispatch_command(ui, config, engine, "/codemode on")
             elif choice == "agent":
                 _dispatch_command(ui, config, engine, "/agent on")
-            elif choice == "assist":
-                _dispatch_command(ui, config, engine, "/assist on")
             elif choice == "memory":
                 _dispatch_command(ui, config, engine, "/codemode status")
             elif choice == "settings":

seedcode/cli.py

@@ -9,9 +9,30 @@ traceback. Heavy imports are deferred into :func:`main` so ``--version``
 
 from __future__ import annotations
 
+import os
 import sys
 
 
+def _interactive() -> bool:
+    """True when a real console is attached (the TUI needs one to draw)."""
+    try:
+        return sys.stdin.isatty() and sys.stdout.isatty()
+    except (AttributeError, ValueError):
+        return False
+
+
+def _use_persistent_tui(plain: bool) -> bool:
+    """Whether to start the persistent TUI instead of the sequential console.
+
+    The TUI owns the whole screen, so it is only used on a real interactive
+    console, never when the host mangles ANSI (``SEEDCODE_PLAIN``) or the user
+    opts out with ``SEEDCODE_NO_TUI``.
+    """
+    if plain or os.environ.get("SEEDCODE_NO_TUI"):
+        return False
+    return _interactive()
+
+
 def _prepare_console() -> None:
     """Make stdout/stderr UTF-8-safe, primarily for Windows.
 
@@ -86,7 +107,14 @@ def main() -> None:
 
     ui = UI(plain=terminal.plain)
     try:
-        run(ui)
+        if _use_persistent_tui(terminal.plain):
+            # v8.2.5: a real console gets the persistent three-region TUI;
+            # every other host keeps the sequential console experience.
+            from .app import run_persistent
+
+            run_persistent()
+        else:
+            run(ui)
         log.info("Clean exit.")
     except KeyboardInterrupt:
         ui.blank()

seedcode/codemode_state.py

@@ -1,6 +1,6 @@
 """Code Mode state (v6.2.0): workspace-aware coding agent session state.
 
-Code Mode is Assist Mode sharpened for the current project:
+Code Mode is the workspace-aware coding mode for the current project:
 
 * the CWD at ``/codemode on`` becomes the *workspace* root;
 * ``.seedcode/`` project memory is ensured and the index refreshed

seedcode/commands/agent.py

@@ -1,8 +1,10 @@
-"""Legacy commands: /agent and /permission.
+"""Agent Mode commands: /agent and /permission (v8.2.5).
 
-The old Agent Mode was merged into Assist Mode — /agent now routes there.
-/permission keeps its dedicated interactive picker; /index and /tools stay
-as inspection commands.
+/agent is the primary route into Agent Mode — the unified autonomous
+workspace/coding agent that the retired Code Mode and Assist Mode folded
+into. /assist, /desktop and /codemode remain accepted aliases so an existing
+habit keeps working. /permission keeps its dedicated interactive picker;
+/index and /tools stay as inspection commands.
 """
 
 from __future__ import annotations
@@ -15,7 +17,7 @@ from . import CommandContext, CommandResult, command, show_session_bar
 from .assist import disable_assist, enable_assist
 
 
-@command("agent", "Legacy alias for Assist Mode. Usage: /agent [on|off]")
+@command("agent", "Select Agent Mode (general-purpose execution). Usage: /agent [on|off]")
 def _agent(ctx: CommandContext, arg: str) -> CommandResult:
     raw = arg.strip().lower()
     if raw in ("on", "off"):
@@ -27,8 +29,6 @@ def _agent(ctx: CommandContext, arg: str) -> CommandResult:
         ctx.ui.dim("Expected: /agent on|off")
         return CommandResult()
 
-    # Agent Mode was merged into Assist Mode — route there transparently.
-    ctx.ui.dim("(/agent is now Assist Mode)")
     if enable:
         enable_assist(ctx.ui, ctx.config)
     else:
@@ -39,7 +39,7 @@ def _agent(ctx: CommandContext, arg: str) -> CommandResult:
 
 @command(
     "permission",
-    "Show or set the Assist permission mode",
+    "Show or set the tool permission level",
     aliases=("perm", "permissions"),
 )
 def _permission(ctx: CommandContext, arg: str) -> CommandResult:
@@ -85,7 +85,7 @@ def _index(ctx: CommandContext, arg: str) -> CommandResult:
     return CommandResult()
 
 
-@command("tools", "List the tools available in Assist Mode")
+@command("tools", "List the tools available to the agent modes")
 def _tools(ctx: CommandContext, arg: str) -> CommandResult:
     from ..ui.layout import columns_grid
 
@@ -95,6 +95,6 @@ def _tools(ctx: CommandContext, arg: str) -> CommandResult:
         kind = "changes files/system" if tool.mutates else "read-only"
         rows.append((name, f"{tool.description}  ({kind})"))
     ctx.ui.panel(
-        columns_grid(rows, ("seed.primary", "seed.text")), title="Assist Tools"
+        columns_grid(rows, ("seed.primary", "seed.text")), title="Agent Tools"
     )
     return CommandResult()