klaude-code 2.2.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

klaude_code/tui/command/__init__.py

@@ -35,12 +35,11 @@ def ensure_commands_loaded() -> None:
     from .export_cmd import ExportCommand
     from .export_online_cmd import ExportOnlineCommand
     from .fork_session_cmd import ForkSessionCommand
-    from .help_cmd import HelpCommand
     from .model_cmd import ModelCommand
     from .refresh_cmd import RefreshTerminalCommand
-    from .release_notes_cmd import ReleaseNotesCommand
     from .resume_cmd import ResumeCommand
     from .status_cmd import StatusCommand
+    from .sub_agent_model_cmd import SubAgentModelCommand
     from .terminal_setup_cmd import TerminalSetupCommand
     from .thinking_cmd import ThinkingCommand
 
@@ -49,13 +48,12 @@ def ensure_commands_loaded() -> None:
     register(ExportCommand())
     register(RefreshTerminalCommand())
     register(ModelCommand())
+    register(SubAgentModelCommand())
     register(ThinkingCommand())
     register(ForkSessionCommand())
     load_prompt_commands()
     register(StatusCommand())
     register(ResumeCommand())
-    register(HelpCommand())
-    register(ReleaseNotesCommand())
     register(ExportOnlineCommand())
     register(TerminalSetupCommand())
     register(DebugCommand())
@@ -73,12 +71,11 @@ def __getattr__(name: str) -> object:
         "ExportCommand": "export_cmd",
         "ExportOnlineCommand": "export_online_cmd",
         "ForkSessionCommand": "fork_session_cmd",
-        "HelpCommand": "help_cmd",
         "ModelCommand": "model_cmd",
         "RefreshTerminalCommand": "refresh_cmd",
-        "ReleaseNotesCommand": "release_notes_cmd",
         "ResumeCommand": "resume_cmd",
         "StatusCommand": "status_cmd",
+        "SubAgentModelCommand": "sub_agent_model_cmd",
         "TerminalSetupCommand": "terminal_setup_cmd",
         "ThinkingCommand": "thinking_cmd",
     }

klaude_code/tui/command/clear_cmd.py

@@ -22,5 +22,4 @@ class ClearCommand(CommandABC):
 
         return CommandResult(
             operations=[op.ClearSessionOperation(session_id=agent.session.id)],
-            persist=False,
         )

klaude_code/tui/command/command_abc.py

@@ -37,14 +37,16 @@ class CommandResult(BaseModel):
     """Result of a command execution."""
 
     events: (
-        list[protocol_events.DeveloperMessageEvent | protocol_events.WelcomeEvent | protocol_events.ReplayHistoryEvent]
+        list[
+            protocol_events.CommandOutputEvent
+            | protocol_events.ErrorEvent
+            | protocol_events.WelcomeEvent
+            | protocol_events.ReplayHistoryEvent
+        ]
         | None
     ) = None  # List of UI events to display immediately
     operations: list[op.Operation] | None = None
 
-    # Persistence controls: some slash commands are UI/control actions and should not be written to session history.
-    persist: bool = True
-
 
 class CommandABC(ABC):
     """Abstract base class for slash commands."""

klaude_code/tui/command/copy_cmd.py

@@ -1,4 +1,4 @@
-from klaude_code.protocol import commands, events, message, model
+from klaude_code.protocol import commands, events, message
 from klaude_code.tui.input.clipboard import copy_to_clipboard
 
 from .command_abc import Agent, CommandABC, CommandResult
@@ -20,10 +20,10 @@ class CopyCommand(CommandABC):
 
         last = _get_last_assistant_text(agent.session.conversation_history)
         if not last:
-            return _developer_message(agent, "(no assistant message to copy)", self.name)
+            return _command_output(agent, "(no assistant message to copy)", self.name, is_error=True)
 
         copy_to_clipboard(last)
-        return _developer_message(agent, "Copied last assistant message to clipboard.", self.name)
+        return _command_output(agent, "Copied last assistant message to clipboard.", self.name)
 
 
 def _get_last_assistant_text(history: list[message.HistoryEvent]) -> str:
@@ -37,16 +37,16 @@ def _get_last_assistant_text(history: list[message.HistoryEvent]) -> str:
     return ""
 
 
-def _developer_message(agent: Agent, content: str, command_name: commands.CommandName) -> CommandResult:
+def _command_output(
+    agent: Agent, content: str, command_name: commands.CommandName, *, is_error: bool = False
+) -> CommandResult:
     return CommandResult(
         events=[
-            events.DeveloperMessageEvent(
+            events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(content),
-                    ui_extra=model.build_command_output_extra(command_name),
-                ),
+                command_name=command_name,
+                content=content,
+                is_error=is_error,
             )
         ],
-        persist=False,
     )

klaude_code/tui/command/debug_cmd.py

@@ -1,5 +1,5 @@
 from klaude_code.log import DebugType, get_current_log_file, is_debug_enabled, set_debug_logging
-from klaude_code.protocol import commands, events, message, model
+from klaude_code.protocol import commands, events, message
 
 from .command_abc import Agent, CommandABC, CommandResult
 
@@ -52,7 +52,7 @@ class DebugCommand(CommandABC):
         # /debug (no args) - enable debug
         if not raw:
             set_debug_logging(True, write_to_file=True)
-            return self._message_result(agent, _format_status())
+            return self._command_output(agent, _format_status())
 
         # /debug <filters> - enable with filters
         try:
@@ -60,21 +60,22 @@ class DebugCommand(CommandABC):
             if filters:
                 set_debug_logging(True, write_to_file=True, filters=filters)
                 filter_names = ", ".join(sorted(dt.value for dt in filters))
-                return self._message_result(agent, f"Filters: {filter_names}\n{_format_status()}")
+                return self._command_output(agent, f"Filters: {filter_names}\n{_format_status()}")
         except ValueError:
             pass
 
-        return self._message_result(agent, f"Invalid filter: {raw}\nValid: {', '.join(dt.value for dt in DebugType)}")
+        return self._command_output(
+            agent, f"Invalid filter: {raw}\nValid: {', '.join(dt.value for dt in DebugType)}", is_error=True
+        )
 
-    def _message_result(self, agent: "Agent", content: str) -> CommandResult:
+    def _command_output(self, agent: "Agent", content: str, *, is_error: bool = False) -> CommandResult:
         return CommandResult(
             events=[
-                events.DeveloperMessageEvent(
+                events.CommandOutputEvent(
                     session_id=agent.session.id,
-                    item=message.DeveloperMessage(
-                        parts=message.text_parts_from_str(content),
-                        ui_extra=model.build_command_output_extra(self.name),
-                    ),
+                    command_name=self.name,
+                    content=content,
+                    is_error=is_error,
                 )
             ]
         )

klaude_code/tui/command/export_online_cmd.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from rich.console import Console
 from rich.text import Text
 
-from klaude_code.protocol import commands, events, message, model
+from klaude_code.protocol import commands, events, message
 from klaude_code.session.export import build_export_html
 
 from .command_abc import Agent, CommandABC, CommandResult
@@ -39,54 +39,49 @@ class ExportOnlineCommand(CommandABC):
         # Check if npx or surge is available
         surge_cmd = self._get_surge_command()
         if not surge_cmd:
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str("surge.sh CLI not found. Install with: npm install -g surge"),
-                    ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                ),
+                command_name=self.name,
+                content="surge.sh CLI not found. Install with: npm install -g surge",
+                is_error=True,
             )
             return CommandResult(events=[event])
 
         try:
             console = Console()
             # Check login status inside status context since npx surge whoami can be slow
-            with console.status(Text("Checking surge.sh login status…", style="dim"), spinner_style="dim"):
+            with console.status(Text("Checking surge.sh login status...", style="dim"), spinner_style="dim"):
                 logged_in = self._is_surge_logged_in(surge_cmd)
 
             if not logged_in:
                 login_cmd = " ".join([*surge_cmd, "login"])
-                event = events.DeveloperMessageEvent(
+                event = events.CommandOutputEvent(
                     session_id=agent.session.id,
-                    item=message.DeveloperMessage(
-                        parts=message.text_parts_from_str(f"Not logged in to surge.sh. Please run: {login_cmd}"),
-                        ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                    ),
+                    command_name=self.name,
+                    content=f"Not logged in to surge.sh. Please run: {login_cmd}",
+                    is_error=True,
                 )
                 return CommandResult(events=[event])
 
-            with console.status(Text("Deploying to surge.sh…", style="dim"), spinner_style="dim"):
+            with console.status(Text("Deploying to surge.sh...", style="dim"), spinner_style="dim"):
                 html_doc = self._build_html(agent)
                 domain = self._generate_domain()
                 url = self._deploy_to_surge(surge_cmd, html_doc, domain)
 
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(f"Session deployed to: {url}"),
-                    ui_extra=model.build_command_output_extra(self.name),
-                ),
+                command_name=self.name,
+                content=f"Session deployed to: {url}",
             )
             return CommandResult(events=[event])
         except Exception as exc:
             import traceback
 
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(f"Failed to deploy session: {exc}\n{traceback.format_exc()}"),
-                    ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                ),
+                command_name=self.name,
+                content=f"Failed to deploy session: {exc}\n{traceback.format_exc()}",
+                is_error=True,
             )
             return CommandResult(events=[event])
 

klaude_code/tui/command/fork_session_cmd.py

@@ -31,7 +31,7 @@ FORK_SELECT_STYLE = Style(
 class ForkPoint:
     """A fork point in conversation history."""
 
-    history_index: int | None  # None means fork entire conversation
+    history_index: int  # -1 means fork entire conversation
     user_message: str
     tool_call_stats: dict[str, int]  # tool_name -> count
     last_assistant_summary: str
@@ -94,7 +94,7 @@ def _build_fork_points(conversation_history: list[message.HistoryEvent]) -> list
     if user_indices:
         fork_points.append(
             ForkPoint(
-                history_index=None,  # None means fork entire conversation
+                history_index=-1,  # None means fork entire conversation
                 user_message="",  # No specific message, this represents the end
                 tool_call_stats={},
                 last_assistant_summary="",
@@ -104,9 +104,9 @@ def _build_fork_points(conversation_history: list[message.HistoryEvent]) -> list
     return fork_points
 
 
-def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | None]]:
+def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int]]:
     """Build SelectItem list from fork points."""
-    items: list[SelectItem[int | None]] = []
+    items: list[SelectItem[int]] = []
 
     for i, fp in enumerate(fork_points):
         is_first = i == 0
@@ -116,8 +116,8 @@ def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | N
         title_parts: list[tuple[str, str]] = []
 
         # First line: separator (with special markers for first/last fork points)
-        if is_first and not is_last:
-            title_parts.append(("class:separator", "----- fork from here (empty session) -----\n\n"))
+        if is_first:
+            pass
         elif is_last:
             title_parts.append(("class:separator", "----- fork from here (entire session) -----\n\n"))
         else:
@@ -150,17 +150,16 @@ def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | N
     return items
 
 
-def _select_fork_point_sync(fork_points: list[ForkPoint]) -> int | None | Literal["cancelled"]:
+def _select_fork_point_sync(fork_points: list[ForkPoint]) -> int | Literal["cancelled"]:
     """Interactive fork point selection (sync version for asyncio.to_thread).
 
     Returns:
-        - int: history index to fork at (exclusive)
-        - None: fork entire conversation
+        - int: history index to fork at (exclusive), -1 means fork entire conversation
         - "cancelled": user cancelled selection
     """
     items = _build_select_items(fork_points)
     if not items:
-        return None
+        return -1
 
     # Default to the last option (fork entire conversation)
     last_value = items[-1].value
@@ -204,14 +203,13 @@ class ForkSessionCommand(CommandABC):
         del user_input  # unused
 
         if agent.session.messages_count == 0:
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str("(no messages to fork)"),
-                    ui_extra=model.build_command_output_extra(self.name),
-                ),
+                command_name=self.name,
+                content="(no messages to fork)",
+                is_error=True,
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
 
         # Build fork points from conversation history
         fork_points = _build_fork_points(agent.session.conversation_history)
@@ -224,51 +222,49 @@ class ForkSessionCommand(CommandABC):
             resume_cmd = f"klaude --resume-by-id {new_session.id}"
             copy_to_clipboard(resume_cmd)
 
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(f"Session forked successfully. New session id: {new_session.id}"),
-                    ui_extra=model.build_command_output_extra(
-                        self.name,
-                        ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
-                    ),
-                ),
+                command_name=self.name,
+                content=f"Session forked successfully. New session id: {new_session.id}",
+                ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
 
         # Interactive selection
         selected = await asyncio.to_thread(_select_fork_point_sync, fork_points)
 
         if selected == "cancelled":
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str("(fork cancelled)"),
-                    ui_extra=model.build_command_output_extra(self.name),
-                ),
+                command_name=self.name,
+                content="(fork cancelled)",
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
+
+        # First option (empty session) is just for UI display, not a valid fork point
+        if selected == fork_points[0].history_index:
+            event = events.CommandOutputEvent(
+                session_id=agent.session.id,
+                command_name=self.name,
+                content="(cannot fork to empty session)",
+                is_error=True,
+            )
+            return CommandResult(events=[event])
 
         # Perform the fork
         new_session = agent.session.fork(until_index=selected)
         await new_session.wait_for_flush()
 
         # Build result message
-        fork_description = "entire conversation" if selected is None else f"up to message index {selected}"
+        fork_description = "entire conversation" if selected == -1 else f"up to message index {selected}"
 
         resume_cmd = f"klaude --resume-by-id {new_session.id}"
         copy_to_clipboard(resume_cmd)
 
-        event = events.DeveloperMessageEvent(
+        event = events.CommandOutputEvent(
             session_id=agent.session.id,
-            item=message.DeveloperMessage(
-                parts=message.text_parts_from_str(
-                    f"Session forked ({fork_description}). New session id: {new_session.id}"
-                ),
-                ui_extra=model.build_command_output_extra(
-                    self.name,
-                    ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
-                ),
-            ),
+            command_name=self.name,
+            content=f"Session forked ({fork_description}). New session id: {new_session.id}",
+            ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
         )
-        return CommandResult(events=[event], persist=False)
+        return CommandResult(events=[event])

klaude_code/tui/command/model_cmd.py

@@ -1,46 +1,9 @@
 import asyncio
 
-from prompt_toolkit.styles import Style
-
-from klaude_code.protocol import commands, events, message, model, op
-from klaude_code.tui.terminal.selector import SelectItem, select_one
+from klaude_code.protocol import commands, events, message, op
 
 from .command_abc import Agent, CommandABC, CommandResult
-from .model_select import select_model_interactive
-
-SELECT_STYLE = Style(
-    [
-        ("instruction", "ansibrightblack"),
-        ("pointer", "ansigreen"),
-        ("highlighted", "ansigreen"),
-        ("text", "ansibrightblack"),
-        ("question", "bold"),
-    ]
-)
-
-
-def _confirm_change_default_model_sync(selected_model: str) -> bool:
-    items: list[SelectItem[bool]] = [
-        SelectItem(title=[("class:text", "No  (session only)\n")], value=False, search_text="No"),
-        SelectItem(
-            title=[("class:text", "Yes (save as default main_model in ~/.klaude/klaude-config.yaml)\n")],
-            value=True,
-            search_text="Yes",
-        ),
-    ]
-
-    try:
-        result = select_one(
-            message=f"Save '{selected_model}' as default model?",
-            items=items,
-            pointer="→",
-            style=SELECT_STYLE,
-            use_search_filter=False,
-        )
-    except KeyboardInterrupt:
-        return False
-
-    return bool(result)
+from .model_picker import ModelSelectStatus, select_model_interactive
 
 
 class ModelCommand(CommandABC):
@@ -52,7 +15,7 @@ class ModelCommand(CommandABC):
 
     @property
     def summary(self) -> str:
-        return "Select and switch LLM"
+        return "Change model (saves to config)"
 
     @property
     def is_interactive(self) -> bool:
@@ -67,28 +30,26 @@ class ModelCommand(CommandABC):
         return "model name"
 
     async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
-        selected_model = await asyncio.to_thread(select_model_interactive, preferred=user_input.text)
+        model_result = await asyncio.to_thread(select_model_interactive, preferred=user_input.text)
 
-        current_model = agent.profile.llm_client.model_name if agent.profile else None
+        current_model = agent.session.model_config_name
+        selected_model = model_result.model if model_result.status == ModelSelectStatus.SELECTED else None
         if selected_model is None or selected_model == current_model:
             return CommandResult(
                 events=[
-                    events.DeveloperMessageEvent(
+                    events.CommandOutputEvent(
                         session_id=agent.session.id,
-                        item=message.DeveloperMessage(
-                            parts=message.text_parts_from_str("(no change)"),
-                            ui_extra=model.build_command_output_extra(self.name),
-                        ),
+                        command_name=self.name,
+                        content="(no change)",
                     )
                 ]
             )
-        save_as_default = await asyncio.to_thread(_confirm_change_default_model_sync, selected_model)
         return CommandResult(
             operations=[
                 op.ChangeModelOperation(
                     session_id=agent.session.id,
                     model_name=selected_model,
-                    save_as_default=save_as_default,
+                    save_as_default=True,
                 )
             ]
         )

klaude_code/tui/command/model_picker.py

@@ -0,0 +1,142 @@
+"""Interactive model selection for CLI."""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+from enum import Enum
+
+from klaude_code.config.config import load_config
+from klaude_code.config.model_matcher import match_model_from_config
+from klaude_code.log import log
+
+
+class ModelSelectStatus(Enum):
+    SELECTED = "selected"
+    CANCELLED = "cancelled"
+    NO_MATCH = "no_match"
+    NO_MODELS = "no_models"
+    NON_TTY = "non_tty"
+    ERROR = "error"
+
+
+@dataclass
+class ModelSelectResult:
+    status: ModelSelectStatus
+    model: str | None = None
+
+
+def select_model_interactive(
+    preferred: str | None = None,
+    keywords: list[str] | None = None,
+) -> ModelSelectResult:
+    """Interactive single-choice model selector.
+
+    This function combines matching logic with interactive UI selection.
+    For CLI usage.
+
+    If keywords is provided, preferred is ignored and the model list is pre-filtered by model_id.
+
+    If preferred is provided:
+    - Exact match: return immediately
+    - Single partial match (case-insensitive): return immediately
+    - Otherwise: fall through to interactive selection
+    """
+    config = load_config()
+    result = match_model_from_config(None if keywords else preferred)
+
+    if result.error_message:
+        return ModelSelectResult(status=ModelSelectStatus.NO_MODELS)
+
+    if result.matched_model:
+        return ModelSelectResult(status=ModelSelectStatus.SELECTED, model=result.matched_model)
+
+    if keywords:
+        keywords_lower = [k.lower() for k in keywords]
+        filtered_models = [
+            m for m in result.filtered_models if any(kw in (m.model_id or "").lower() for kw in keywords_lower)
+        ]
+        if not filtered_models:
+            return ModelSelectResult(status=ModelSelectStatus.NO_MATCH)
+        result.filtered_models = filtered_models
+        result.filter_hint = ", ".join(keywords)
+        result.matched_model = None
+
+    # Non-interactive environments (CI/pipes) should never enter an interactive prompt.
+    # If we couldn't resolve to a single model deterministically above, fail with a clear hint.
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        log(("Error: cannot use interactive model selection without a TTY", "red"))
+        log(("Hint: pass --model <config-name> or set main_model in ~/.klaude/klaude-config.yaml", "yellow"))
+        if preferred and not keywords:
+            log((f"Hint: '{preferred}' did not resolve to a single configured model", "yellow"))
+        return ModelSelectResult(status=ModelSelectStatus.NON_TTY)
+
+    # Interactive selection
+    from prompt_toolkit.styles import Style
+
+    from klaude_code.tui.terminal.selector import build_model_select_items, select_one
+
+    names = [m.selector for m in result.filtered_models]
+
+    try:
+        items = build_model_select_items(result.filtered_models)
+
+        message = f"Select a model (filtered by '{result.filter_hint}'):" if result.filter_hint else "Select a model:"
+
+        initial_value = config.main_model
+        if isinstance(initial_value, str) and initial_value and "@" not in initial_value:
+            try:
+                resolved = config.resolve_model_location_prefer_available(
+                    initial_value
+                ) or config.resolve_model_location(initial_value)
+            except ValueError:
+                resolved = None
+            if resolved is not None:
+                initial_value = f"{resolved[0]}@{resolved[1]}"
+
+        selected = select_one(
+            message=message,
+            items=items,
+            pointer="→",
+            use_search_filter=True,
+            initial_value=initial_value,
+            style=Style(
+                [
+                    ("pointer", "ansigreen"),
+                    ("highlighted", "ansigreen"),
+                    ("msg", ""),
+                    ("meta", "fg:ansibrightblack"),
+                    ("text", "ansibrightblack"),
+                    ("question", "bold"),
+                    ("search_prefix", "ansibrightblack"),
+                    # search filter colors at the bottom
+                    ("search_success", "noinherit fg:ansigreen"),
+                    ("search_none", "noinherit fg:ansired"),
+                ]
+            ),
+        )
+        if isinstance(selected, str) and selected in names:
+            return ModelSelectResult(status=ModelSelectStatus.SELECTED, model=selected)
+    except KeyboardInterrupt:
+        return ModelSelectResult(status=ModelSelectStatus.CANCELLED)
+    except Exception as e:
+        log((f"Failed to use prompt_toolkit for model selection: {e}", "yellow"))
+        # Never return an unvalidated model name here.
+        # If we can't interactively select, fall back to a known configured model.
+        if result.matched_model and result.matched_model in names:
+            return ModelSelectResult(status=ModelSelectStatus.SELECTED, model=result.matched_model)
+        if config.main_model and config.main_model in names:
+            return ModelSelectResult(status=ModelSelectStatus.SELECTED, model=config.main_model)
+        if config.main_model and "@" not in config.main_model:
+            try:
+                resolved = config.resolve_model_location_prefer_available(
+                    config.main_model
+                ) or config.resolve_model_location(config.main_model)
+            except ValueError:
+                resolved = None
+            if resolved is not None:
+                selector = f"{resolved[0]}@{resolved[1]}"
+                if selector in names:
+                    return ModelSelectResult(status=ModelSelectStatus.SELECTED, model=selector)
+
+    return ModelSelectResult(status=ModelSelectStatus.ERROR)

klaude_code/tui/command/refresh_cmd.py

@@ -38,5 +38,4 @@ class RefreshTerminalCommand(CommandABC):
                     is_load=False,
                 ),
             ],
-            persist=False,
         )