seedcode-cli 8.2.5__py3-none-any.whl → 9.1.1__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__ = "8.2.5"
+__version__ = "9.1.1"
 __author__ = "Al Shahriar Sowan"
 __publisher__ = "Eagox Studio"
 # Current author/company links, surfaced by /about and the README credits.

seedcode/_default_key_template.py

@@ -1,4 +1,4 @@
-"""Embedded built-in credential for the Default provider (v7.1.0 artifact).
+"""Embedded built-in credential for the Default provider (v9.1.1 artifact).
 
 This file is NOT committed to source control. The release build generates
 ``seedcode/_default_key.py`` from the local ``.env`` (see

seedcode/app.py

@@ -15,12 +15,15 @@ Ctrl+L clear screen.
 from __future__ import annotations
 
 import sys
+import threading
+import time
+from pathlib import Path
 
 from prompt_toolkit import PromptSession
 from prompt_toolkit.key_binding import KeyBindings
 
 from . import __version__
-from .commands import CommandContext, dispatch, is_command
+from .commands import CommandContext, CommandResult, dispatch, is_command
 from .commands.about import show_about
 from .commands.help import show_shortcuts
 from .commands.history import browse_history, settings_menu
@@ -30,6 +33,7 @@ from .commands.theme import pick_theme
 from .config import load_config
 from .core.agent import AgentEngine, strip_tool_blocks
 from .core.chat import ChatEngine, ChatError
+from .core.intent import Intent, classify
 from .core.lifecycle import LifecycleError, lifecycle
 from .core.models import AppConfig
 from .core.providers import (
@@ -44,6 +48,7 @@ from .tools import PermissionManager, PermissionMode
 from .ui import UI
 from .ui.badges import badge_for_status
 from .ui.menu import MenuItem, run_menu
+from .ui.mode_switch import ModeSwitcher
 from .ui.reference import CONTROLS_HINT, INPUT_HINT
 from .ui.state import AppState, Status
 from .ui.tasks import TaskFlow, TaskState, activity_for
@@ -168,7 +173,7 @@ def _workspace_status(config: AppConfig) -> str:
 def _main_menu(config: AppConfig):
     """The interactive main menu; returns an action id or None (exit).
 
-    v8.2.5 layout: the mode/setup actions carry Ctrl+1..Ctrl+4 shortcuts that
+    v9.1.0 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
@@ -241,9 +246,52 @@ def _guided_setup(ui: UI, config: AppConfig) -> bool:
     return config.is_configured()
 
 
-def _handle_chat(ui: UI, engine: ChatEngine, history: HistoryStore, text: str) -> None:
-    """Send a user turn to the model and stream the reply to screen."""
-    engine.add_user(text)
+def _retrieve_context(ui: UI, intent: Intent, text: str) -> str:
+    """Fetch fresh external information for a research request (v9.1.1).
+
+    Returns a bounded context block, or '' when retrieval is disabled, fails,
+    or finds nothing. The caller shows a lightweight status and continues — a
+    failed lookup must never stop the answer. Nothing here is fatal.
+    """
+    try:
+        from .core import internet
+
+        if internet.internet_disabled():
+            return ""
+        ui.dim("[Accessing internet...]")
+        result = internet.research(intent.target or text)
+        if not result.ok:
+            ui.dim("[No online sources available]")
+            return ""
+        if result.excerpts:
+            ui.dim("[Reading relevant sources...]")
+        return internet.context_block(result)
+    except Exception:  # retrieval must never break a turn
+        _log.exception("internet retrieval failed")
+        return ""
+
+
+def _handle_chat(
+    ui: UI,
+    engine: ChatEngine,
+    history: HistoryStore,
+    text: str,
+    intent: Intent | None = None,
+) -> None:
+    """Send a user turn to the model and stream the reply to screen.
+
+    When the request needs current information, only a lightweight status is
+    shown (``[Accessing internet...]`` / ``[Reading relevant sources...]``)
+    and the retrieved sources are prepended to the turn; the browsing itself
+    is never exposed line by line.
+    """
+    resolved = intent or classify(text)
+    outgoing = text
+    if resolved.needs_internet:
+        block = _retrieve_context(ui, resolved, text)
+        if block:
+            outgoing = block + "\n\n" + text
+    engine.add_user(outgoing)
     renderer = None
     try:
         chunks = engine.stream_reply()
@@ -487,6 +535,24 @@ def _advance(lc, method: str) -> None:
         _log.debug("lifecycle transition %s skipped", method)
 
 
+#: How long an Agent Mode turn waits for a background mode initialization that
+#: is still running before it gets on with building its own engine. The wait
+#: happens on the turn's worker thread, so nothing on screen is ever held up.
+_AGENT_INIT_WAIT_S = 20.0
+
+
+def _is_mode_command(text: str) -> bool:
+    """Whether ``text`` is an in-place mode transition (single source: the TUI).
+
+    Imported lazily so the controller can route a mode command to the
+    background worker without pulling prompt_toolkit into every entry point
+    that merely imports this module.
+    """
+    from .ui.tui import _is_mode_command as _is
+
+    return _is(text)
+
+
 def _codemode_enabled() -> bool:
     """Whether Code Mode is active (the persistent-session path)."""
     try:
@@ -698,15 +764,23 @@ def _report_session_summary(ui: UI, session) -> None:
         # A skipped task is resolved, never counted as verified work.
         ui.dim(f"  • Skipped: {skipped} task(s) not needed")
     evidence = session.session_evidence
+    changed = list(session.state.changed_files)
     if evidence.tests:
         # What matters is the final state: the last test run passed.
         passed = evidence.tests[-1].ok
         ui.dim(f"  ✓ Verification: {'accepted' if passed else 'tests NOT passing'}")
         ui.dim(f"  ✓ Tests: {'passed' if passed else 'FAILED'}")
+    elif changed:
+        # Completion is evidence-gated (a task never verifies with zero
+        # observed work), so "accepted" here means files were really written.
+        ui.dim(
+            f"  ✓ Verification: accepted ({len(changed)} file(s) created/modified)"
+        )
     else:
-        ui.dim("  ✓ Verification: accepted (no test run in this project)")
-    if session.state.changed_files:
-        ui.dim(f"  ✓ Files: {len(session.state.changed_files)} affected")
+        ui.dim("  ✓ Verification: accepted (commands ran and succeeded)")
+    if changed:
+        shown = ", ".join(changed[-5:])
+        ui.dim(f"  ✓ Files: {len(changed)} affected — {shown}")
     commands = evidence.commands
     if commands:
         ok = sum(1 for record in commands if record.ok)
@@ -807,12 +881,22 @@ def _handle_agent(
 def _make_agent(
     ui: UI, config: AppConfig, presenter: "_TaskPresenter | None" = None
 ) -> AgentEngine:
-    """Build an Agent Mode engine bound to the CWD and configured permissions."""
+    """Build an Agent Mode engine bound to the ACTIVE WORKSPACE and permissions.
+
+    The workspace is the folder the user selected at startup (or via
+    ``/workspace``), so every file operation the engine performs resolves
+    against it and stays inside it unless the permission system explicitly
+    authorizes an outside write.
+    """
     # 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
+    from .workspace import active_workspace
 
-    permissions = PermissionManager(level=PermissionMode.parse(config.permission_mode))
+    permissions = PermissionManager(
+        level=PermissionMode.parse(config.permission_mode),
+        workspace=active_workspace(),
+    )
     # Desktop capability is a property of the permission level now: attach the
     # Computer Engine gate whenever the level is Desktop or higher and the
     # engine is actually available on this machine.
@@ -835,12 +919,24 @@ def _make_agent(
     return engine
 
 
+# The process-wide dangerous-action gate (v9.1.1). It is created once, not
+# once per engine: the agent engine is rebuilt whenever the permission level or
+# workspace changes, and re-creating the gate there was resetting the user's
+# "Allow" / "Allow All" answers mid-task — the repeated-permission-prompt bug.
+# A grant now survives every tool call, every multi-step task and every engine
+# rebuild, exactly as the session-scope answer promises.
+_ACTION_GATE = None
+_ACTION_GATE_LOCK = threading.Lock()
+
+
 def _make_action_gate(ui: UI):
-    """Dangerous-action gate wired to the interactive permission dialog.
+    """The session-scoped dangerous-action gate (created once per process).
 
-    Note: the Assist engine (and thus this gate) is rebuilt on permission-mode
-    changes, so session "Always" grants reset then — conservative on purpose.
+    Answers stick for the rest of the session: ``Always Allow`` per category,
+    and ``Allow All`` across every category. Nothing is persisted to disk, so
+    a new process starts clean — the scope is deliberately session-only.
     """
+    global _ACTION_GATE
     from .tools.permissions import ACTION_LABELS, ActionGate, ActionGrant
 
     def confirm(category: str, description: str) -> ActionGrant:
@@ -849,9 +945,20 @@ def _make_action_gate(ui: UI):
         return {
             "y": ActionGrant.ONCE,
             "a": ActionGrant.ALWAYS,
+            "A": ActionGrant.ALL,
         }.get(answer, ActionGrant.DENY)
 
-    return ActionGate(confirm=confirm)
+    with _ACTION_GATE_LOCK:
+        if _ACTION_GATE is None:
+            _ACTION_GATE = ActionGate(confirm=confirm)
+        return _ACTION_GATE
+
+
+def reset_action_gate() -> None:
+    """Forget all session grants (test isolation; also an explicit reset)."""
+    global _ACTION_GATE
+    with _ACTION_GATE_LOCK:
+        _ACTION_GATE = None
 
 
 def _make_desktop_session(ui: UI):
@@ -980,7 +1087,11 @@ def _chat_loop(
         # span's ``finally`` returns the state machine to IDLE and the REPL
         # prompts again. A task can never end the app.
         with lifecycle().task_span():
-            if config.agent_mode:
+            intent = classify(text)
+            if config.agent_mode or intent.executes:
+                # Build (or rebuild) the Agent engine for the live config. A
+                # temporary escalation builds exactly the same engine an
+                # explicit Agent Mode turn would, so behaviour cannot diverge.
                 try:
                     from . import codemode_state as _cms
 
@@ -995,11 +1106,21 @@ def _chat_loop(
                     agent = _make_agent(ui, config, presenter)
                     agent_perm = config.permission_mode
                     agent_codemode = codemode_now
+                if not config.agent_mode:
+                    # Chat Mode escalation: one agent turn, then back to chat.
+                    # The persistent mode is untouched.
+                    ui.dim(f"[Agent assist - {intent.reason}]")
+                    try:
+                        agent.set_intent(intent)  # type: ignore[union-attr]
+                    except Exception:
+                        pass
                 # One task flow per turn: the engine reports real activity into
                 # it, and the REPL keeps prompting when the turn ends.
                 _handle_agent(ui, agent, history, text, presenter)
+                if not config.agent_mode:
+                    ui.dim("[Temporary agent task finished - back to Chat Mode]")
             else:
-                _handle_chat(ui, engine, history, text)
+                _handle_chat(ui, engine, history, text, intent)
 
 
 def _interactive() -> bool:
@@ -1077,7 +1198,7 @@ def _build_chat_session(ui: UI) -> PromptSession:
 
 
 # ---------------------------------------------------------------------------
-# Persistent TUI session (v8.2.5)
+# Persistent TUI session (v9.1.0)
 # ---------------------------------------------------------------------------
 
 
@@ -1112,10 +1233,26 @@ class _TuiController:
         self.agent: AgentEngine | None = None
         self.agent_perm = config.permission_mode
         self.agent_codemode = _codemode_enabled()
+        #: The workspace the live engine was built for. A `/workspace` change
+        #: moves the process working directory, so the engine (whose permission
+        #: manager scopes every file operation to one root) must be rebuilt —
+        #: otherwise writes would keep resolving against the old folder.
+        self.agent_workspace = str(Path.cwd())
         self._backend = config.provider
+        #: Guards the agent engine pointer against a mode switch rebuilding it
+        #: while a turn is reading it (both run on worker threads).
+        self._agent_lock = threading.RLock()
+        #: The single owner of every background mode transition. A switch is a
+        #: state change plus a worker; it is never a bare thread started from a
+        #: UI callback (which is how a switch could freeze the terminal).
+        self.switcher = ModeSwitcher(
+            on_finished=self._switch_finished,
+            on_failed=self._switch_failed,
+        )
         tui.on_submit = self.submit
         # Mode switches run in place: no application exit, no rebuild.
-        tui.on_command = self._inplace_command
+        tui.on_command = self._mode_command
+        tui.on_cancel_init = self._cancel_initialization
 
     # --- provider/backend --------------------------------------------------
     def _on_provider_event(self, kind: str, detail: str) -> None:
@@ -1129,7 +1266,9 @@ class _TuiController:
         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
+        with self._agent_lock:
+            # A new backend means a new engine; drop the old one.
+            self.agent = None
         self._backend = self.config.provider
 
     # --- one turn (worker thread) ------------------------------------------
@@ -1142,20 +1281,199 @@ class _TuiController:
                 self._ensure_agent()
                 _handle_agent(self.ui, self.agent, self.history, text, self.presenter)
             else:
-                _handle_chat(self.ui, self.engine, self.history, text)
+                intent = classify(text)
+                if intent.executes:
+                    # Chat Mode detected a request needing real execution:
+                    # escalate to Agent for THIS turn only, then return to
+                    # Chat. The persistent mode is never changed.
+                    self._run_escalated_turn(text, intent)
+                else:
+                    _handle_chat(self.ui, self.engine, self.history, text, intent)
         try:
             self.tui.sync_from_config(self.config)
         except Exception:
             pass
 
+    def _run_escalated_turn(self, text: str, intent: Intent) -> None:
+        """Run one Agent turn from Chat Mode, then hand control back (v9.1.1).
+
+        This is the *temporary* escalation path: the user stays in Chat Mode,
+        one request is executed with the full agent loop, and the session
+        returns to conversation. Explicit Agent Mode is unaffected and stays
+        active until the user changes it.
+        """
+        self.ui.dim(f"[Agent assist - {intent.reason}]")
+        try:
+            self._ensure_agent()
+            agent = self.agent
+            if agent is None:
+                _handle_chat(self.ui, self.engine, self.history, text, intent)
+                return
+            agent.set_intent(intent)
+            _handle_agent(self.ui, agent, self.history, text, self.presenter)
+        except Exception:  # escalation must never break the session
+            _log.exception("temporary agent escalation failed")
+            self.ui.error("The agent step could not run; answering in Chat Mode.")
+            _handle_chat(self.ui, self.engine, self.history, text, intent)
+        finally:
+            self.ui.dim("[Temporary agent task finished - back to Chat Mode]")
+
+    # --- mode transitions ---------------------------------------------------
+    def _mode_command(self, text: str) -> None:
+        """Handle a mode-switch command from the composer — *never* inline.
+
+        Entering Agent Mode does real work (the ``.seedcode`` workspace scan,
+        the desktop capability probe, and a permission prompt that waits for the
+        user). The permission prompt is answered by the prompt_toolkit event
+        loop, so running any of it on the event-loop thread would wait forever
+        for a key press that thread had already made impossible — the freeze.
+        Every transition therefore runs on the switcher's owned worker.
+        """
+        self._mode_transition(text)
+
+    def _mode_transition(self, text: str) -> int:
+        """Start a mode transition; return immediately, never blocking the loop."""
+        if not self._enters_agent_mode(text):
+            # Leaving Agent Mode — and reporting mode state — is cheap and has
+            # no permission prompt, so it applies here and now, and it cancels
+            # any preparation still in flight. Nothing in this path can wait
+            # for the event loop, so running it on the loop thread is safe.
+            self.switcher.cancel()
+            self.tui.end_initialization()
+            self._inplace_command(text)
+            return self.switcher.generation
+        # Entering Agent Mode: the immediate, cheap half now; everything that
+        # scans, probes or prompts happens on the switcher's owned worker.
+        self._activate_agent_mode_now()
+        return self.switcher.run(
+            "agent", lambda cancel: self._run_mode_command(text, cancel)
+        )
+
+    def _enters_agent_mode(self, text: str) -> bool:
+        """Whether a mode command is turning Agent Mode **on**.
+
+        Mirrors the command layer's own aliases (``/agent``, ``/assist``,
+        ``/desktop``, ``/mode``, ``/codemode``) so the immediate UI state and
+        the background preparation agree. A bare form toggles, which is why the
+        live config is consulted. Getting this wrong is not fatal — the command
+        layer still performs the real switch — it only decides whether the
+        user sees "Initializing..." instantly.
+        """
+        parts = text.strip().lstrip("/").split(maxsplit=1)
+        if not parts:
+            return False
+        head = parts[0].lower()
+        arg = parts[1].strip().lower() if len(parts) > 1 else ""
+        if head in ("agent", "assist", "desktop"):
+            if arg == "on":
+                return True
+            if arg == "off":
+                return False
+            return not self.config.agent_mode  # the bare form toggles
+        if head == "mode":
+            if not arg:
+                return False
+            from .core.modes import Mode, parse_mode
+
+            return parse_mode(arg, default=Mode.CHAT) is Mode.AGENT
+        if head == "codemode":
+            return arg == "on"
+        return False  # /chat, /status and the rest never enter Agent Mode
+
+    def _activate_agent_mode_now(self) -> None:
+        """Apply the cheap half of ``/agent on`` immediately.
+
+        Only the mode change itself (plus its config write): no workspace scan,
+        no capability probe, no permission prompt. Those are what
+        :func:`~seedcode.commands.assist.prepare_agent_mode` does on the worker.
+        """
+        from .commands.assist import activate_agent_mode
+
+        try:
+            activate_agent_mode(self.config)
+        except Exception:
+            _log.exception("could not switch to Agent Mode")
+        with self._agent_lock:
+            # The engine built for Chat Mode must not serve an agent turn.
+            self.agent = None
+        self.tui.begin_initialization("Agent Mode")
+        self.tui.sync_from_config(self.config)
+
+    def _run_mode_command(self, text: str, cancel) -> CommandResult:
+        """The worker body of an Agent Mode entry (runs off the event loop).
+
+        ``cancel`` is the switcher's probe for this transition: it is handed to
+        the command through the context so the workspace scan and the permission
+        prompt stop as soon as this transition is superseded, and everything
+        this worker might report is suppressed once it is stale.
+        """
+        ctx = CommandContext(
+            ui=self.ui,
+            config=self.config,
+            engine=self.engine,
+            cancel=cancel,
+        )
+        backend_before = self.config.provider
+        try:
+            result = dispatch(ctx, text)
+        except (KeyboardInterrupt, EOFError):
+            if not cancel():
+                self.ui.dim("Cancelled.")
+            result = CommandResult()
+        except Exception as exc:  # a broken command must not kill the session
+            if not cancel():
+                _log.exception("mode command failed: %s", text)
+                _report_command_error(self.ui, exc)
+            result = CommandResult()
+        if cancel():
+            return result  # superseded: a newer transition owns the screen
+        if self.config.provider != backend_before:
+            self._rebuild_backend()
+        self.tui.sync_from_config(self.config)
+        return result
+
+    def _cancel_initialization(self) -> None:
+        """Cancel a background Agent Mode preparation (Ctrl+C, Esc, shutdown)."""
+        self.switcher.cancel()
+        self.tui.end_initialization()
+        self.tui.state.set_status(Status.READY, "")
+        self.ui.dim(
+            "(initialization cancelled — still in Agent Mode, preparing when "
+            "needed; /chat on returns to Chat Mode)"
+        )
+
+    def _switch_finished(self, _generation: int, _key: str, _result) -> None:
+        """The background preparation completed (called on the worker)."""
+        with self._agent_lock:
+            self.agent = None  # rebuilt lazily from the now-final config
+        self.tui.end_initialization()
+        try:
+            self.tui.sync_from_config(self.config)
+        except Exception:
+            pass
+
+    def _switch_failed(self, _generation: int, _key: str, error: str) -> None:
+        """A failed preparation is *reported*, never turned into a freeze.
+
+        The terminal keeps running, the header keeps working, and Chat Mode is
+        one command away — exactly the contract for a failure in a mode switch.
+        """
+        with self._agent_lock:
+            self.agent = None
+        self.tui.end_initialization()
+        self.tui.state.set_status(Status.ERROR, "initialization failed")
+        self.ui.error(f"[Agent Mode] Initialization failed: {error}")
+        self.ui.dim("Chat Mode is unaffected — /chat on returns to it.")
+        self.tui.sync_from_config(self.config)
+
     def _inplace_command(self, text: str) -> None:
-        """Dispatch a mode-switch command without leaving the TUI.
+        """Dispatch a command that does not change the mode, in place.
 
-        The engine/agent are rebuilt only when the mode actually changed, and
-        the header is refreshed from live config — a pure state transition.
+        The engine/agent are rebuilt only when the provider actually changed,
+        and the header is refreshed from live config — a pure state transition
+        with no application exit and no rebuild.
         """
         backend_before = self.config.provider
-        mode_before = self.config.mode
         try:
             dispatch(self.ctx, text)
         except (KeyboardInterrupt, EOFError):
@@ -1164,28 +1482,46 @@ class _TuiController:
             _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:
+        """Build the Agent engine for the live config (on the turn worker).
+
+        If a mode switch is still preparing Agent Mode, wait for it here: this
+        runs on the turn's own worker thread, so waiting costs the interface
+        nothing, and it keeps one engine from being built underneath another.
+        The wait is bounded, and Ctrl+C still aborts it.
+        """
+        deadline = time.monotonic() + _AGENT_INIT_WAIT_S
+        while self.tui.state.agent_initializing and time.monotonic() < deadline:
+            self.tui.check_cancel()  # Ctrl+C still aborts the waiting turn
+            if self.switcher.wait(timeout=0.1):
+                break
         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
+        workspace_now = str(Path.cwd())
+        with self._agent_lock:
+            if (
+                self.agent is None
+                or self.agent_perm != self.config.permission_mode
+                or self.agent_codemode != codemode_now
+                or self.agent_workspace != workspace_now
+            ):
+                self.agent = _make_agent(self.ui, self.config, self.presenter)
+                self.agent_perm = self.config.permission_mode
+                self.agent_codemode = codemode_now
+                self.agent_workspace = workspace_now
 
     # --- the session loop --------------------------------------------------
     def run(self) -> None:
         while True:
             kind, payload = self.tui.run_once()
+            # A mode command that somehow reached the main loop (an unexpected
+            # result) still must not be dispatched on the event-loop thread.
+            if kind == "command" and payload and _is_mode_command(payload):
+                self._mode_transition(payload)
+                continue
             if kind == "exit":
-                self.tui.shutdown()
+                self._shutdown()
                 _exit_application(self.ui, "tui exit")
                 return
             if kind == "key":
@@ -1215,7 +1551,7 @@ class _TuiController:
                 continue
             if result.should_exit:
                 if self._menu():
-                    self.tui.shutdown()
+                    self._shutdown()
                     _exit_application(self.ui, "menu exit")
                     return
                 continue
@@ -1223,6 +1559,18 @@ class _TuiController:
                 self._rebuild_backend()
             self.tui.sync_from_config(self.config)
 
+    def _shutdown(self) -> None:
+        """Release the session: stop background work, then the application.
+
+        A background mode initialization is cancelled and given a moment to
+        finish, so no worker outlives the interface it belongs to.
+        """
+        try:
+            self.switcher.cancel(wait=1.0)
+        except Exception:
+            pass  # a teardown hiccup must never stop the session from ending
+        self.tui.shutdown()
+
     def _toolbar_action(self, action: str) -> None:
         """Run a real action behind a header control (provider/model/mode).
 
@@ -1264,7 +1612,9 @@ class _TuiController:
             hint="\u2191\u2193 move   Enter select   Esc cancel",
         )
         if choice:
-            self._command(f"/mode {choice}")
+            # A real mode switch — routed to the background worker, never
+            # dispatched on the event-loop thread.
+            self._mode_transition(f"/mode {choice}")
 
     def _menu(self) -> bool:
         """The interactive main menu; returns True when the user quits."""
@@ -1285,7 +1635,10 @@ class _TuiController:
                 elif choice == "model":
                     select_model(self.ui, self.config)
                 elif choice == "agent":
-                    self._command("/agent on")
+                    # Agent Mode preparation is background work: it must not run
+                    # on the menu's (main) thread, which would deadlock on the
+                    # permission prompt it raises.
+                    self._mode_transition("/agent on")
                 elif choice == "memory":
                     self._command("/codemode status")
                 elif choice == "settings":
@@ -1331,12 +1684,13 @@ def run_persistent(*, input_device=None, output_device=None) -> None:
             return
 
     workspace = str(workspace_root())
-    columns, _rows = _terminal_size()
+    columns, rows = _terminal_size()
     state = AppState.from_config(config, workspace=workspace)
     tui = ChatTUI(
         state,
         workspace=workspace,
         width=columns,
+        height=rows,
         input_device=input_device,
         output_device=output_device,
     )