klaude-code 1.3.0__tar.gz → 1.4.0__tar.gz

{klaude_code-1.3.0 → klaude_code-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.3.0
+Version: 1.4.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
@@ -12,7 +12,6 @@ Requires-Dist: pillow>=12.0.0
 Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: questionary>=2.1.1
 Requires-Dist: rich>=14.1.0
 Requires-Dist: trafilatura>=2.0.0
 Requires-Dist: typer>=0.17.3

{klaude_code-1.3.0 → klaude_code-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.3.0"
+version = "1.4.0"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -19,7 +19,6 @@ dependencies = [
     "prompt-toolkit>=3.0.52",
     "pydantic>=2.11.7",
     "pyyaml>=6.0.2",
-    "questionary>=2.1.1",
     "rich>=14.1.0",
     "trafilatura>=2.0.0",
     "typer>=0.17.3",

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/cli/runtime.py

@@ -273,7 +273,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             display.wrapped_display.renderer.stop_bottom_live()
 
     # Pass the pre-detected theme to avoid redundant TTY queries.
-    # Querying the terminal background again after questionary's interactive selection
+    # Querying the terminal background again after an interactive selection
     # can interfere with prompt_toolkit's terminal state and break history navigation.
     is_light_background: bool | None = None
     if components.theme == "light":
@@ -352,7 +352,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
                 op.UserInputOperation(input=user_input, session_id=active_session_id)
             )
             # If it's an interactive command (e.g., /model), avoid starting the ESC monitor
-            # to prevent TTY conflicts with interactive prompts (questionary/prompt_toolkit).
+            # to prevent TTY conflicts with interactive prompt_toolkit UIs.
             if has_interactive_command(user_input.text):
                 await components.executor.wait_for(submission_id)
             else:

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/cli/session_cmd.py

@@ -7,8 +7,11 @@ from klaude_code.trace import log
 
 
 def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) -> bool:
-    """Show session list and confirm deletion using questionary."""
-    import questionary
+    """Show session list and confirm deletion using prompt_toolkit."""
+
+    from prompt_toolkit.styles import Style
+
+    from klaude_code.ui.terminal.selector import SelectItem, select_one
 
     def _fmt(ts: float) -> str:
         try:
@@ -24,14 +27,26 @@ def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) ->
             first_msg += "..."
         log(f"  {_fmt(s.updated_at)}  {msg_count_display:>3} msgs  {first_msg}")
 
-    return (
-        questionary.confirm(
-            message,
-            default=False,
-            style=questionary.Style([("question", "bold")]),
-        ).ask()
-        or False
+    items: list[SelectItem[bool]] = [
+        SelectItem(title=[("class:text", "No\n")], value=False, search_text="No"),
+        SelectItem(title=[("class:text", "Yes\n")], value=True, search_text="Yes"),
+    ]
+
+    result = select_one(
+        message=message,
+        items=items,
+        pointer="→",
+        style=Style(
+            [
+                ("question", "bold"),
+                ("pointer", "ansigreen"),
+                ("highlighted", "ansigreen"),
+                ("text", ""),
+            ]
+        ),
+        use_search_filter=False,
     )
+    return bool(result)
 
 
 def session_clean(

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/command/model_cmd.py

@@ -1,38 +1,43 @@
 import asyncio
 
-import questionary
+from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.config.select_model import select_model_from_config
 from klaude_code.protocol import commands, events, model, op
+from klaude_code.ui.terminal.selector import SelectItem, select_one
 
-SELECT_STYLE = questionary.Style(
+SELECT_STYLE = Style(
     [
         ("instruction", "ansibrightblack"),
-        ("pointer", "ansicyan"),
-        ("highlighted", "ansicyan"),
+        ("pointer", "ansigreen"),
+        ("highlighted", "ansigreen"),
         ("text", "ansibrightblack"),
+        ("question", ""),
     ]
 )
 
 
 def _confirm_change_default_model_sync(selected_model: str) -> bool:
-    choices: list[questionary.Choice] = [
-        questionary.Choice(title="No  (session only)", value=False),
-        questionary.Choice(title="Yes (save as default main_model in ~/.klaude/klaude-config.yaml)", value=True),
+    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:
         # Add a blank line between the model selector and this confirmation prompt.
-        questionary.print("")
-        result = questionary.select(
+        print("")
+        result = select_one(
             message=f"Save '{selected_model}' as default model?",
-            choices=choices,
+            items=items,
             pointer="→",
-            instruction="Use arrow keys to move, Enter to select",
-            use_jk_keys=False,
             style=SELECT_STYLE,
-        ).ask()
+            use_search_filter=False,
+        )
     except KeyboardInterrupt:
         return False
 

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/command/thinking_cmd.py

@@ -1,9 +1,10 @@
 import asyncio
 
-import questionary
+from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, llm_param, model
+from klaude_code.ui.terminal.selector import SelectItem, select_one
 
 # Thinking level options for different protocols
 RESPONSES_LEVELS = ["low", "medium", "high"]
@@ -118,12 +119,13 @@ def format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
     return "unknown protocol"
 
 
-SELECT_STYLE = questionary.Style(
+SELECT_STYLE = Style(
     [
         ("instruction", "ansibrightblack"),
-        ("pointer", "ansicyan"),
-        ("highlighted", "ansicyan"),
+        ("pointer", "ansigreen"),
+        ("highlighted", "ansigreen"),
         ("text", "ansibrightblack"),
+        ("question", ""),
     ]
 )
 
@@ -131,17 +133,18 @@ SELECT_STYLE = questionary.Style(
 def _select_responses_thinking_sync(model_name: str | None) -> llm_param.Thinking | None:
     """Select thinking level for responses/codex protocol (sync version)."""
     levels = _get_levels_for_responses(model_name)
-    choices: list[questionary.Choice] = [questionary.Choice(title=level, value=level) for level in levels]
+    items: list[SelectItem[str]] = [
+        SelectItem(title=[("class:text", level + "\n")], value=level, search_text=level) for level in levels
+    ]
 
     try:
-        result = questionary.select(
+        result = select_one(
             message="Select reasoning effort:",
-            choices=choices,
+            items=items,
             pointer="→",
-            instruction="Use arrow keys to move, Enter to select",
-            use_jk_keys=False,
             style=SELECT_STYLE,
-        ).ask()
+            use_search_filter=False,
+        )
 
         if result is None:
             return None
@@ -152,22 +155,24 @@ def _select_responses_thinking_sync(model_name: str | None) -> llm_param.Thinkin
 
 def _select_anthropic_thinking_sync() -> llm_param.Thinking | None:
     """Select thinking level for anthropic/openai_compatible protocol (sync version)."""
-    choices: list[questionary.Choice] = [
-        questionary.Choice(title=label, value=tokens) for label, tokens in ANTHROPIC_LEVELS
+    items: list[SelectItem[int]] = [
+        SelectItem(title=[("class:text", label + "\n")], value=tokens or 0, search_text=label)
+        for label, tokens in ANTHROPIC_LEVELS
     ]
 
     try:
-        result = questionary.select(
+        result = select_one(
             message="Select thinking level:",
-            choices=choices,
+            items=items,
             pointer="→",
-            instruction="Use arrow keys to move, Enter to select",
-            use_jk_keys=False,
             style=SELECT_STYLE,
-        ).ask()
-        if not result:
+            use_search_filter=False,
+        )
+        if result is None:
+            return None
+        if result == 0:
             return llm_param.Thinking(type="disabled", budget_tokens=0)
-        return llm_param.Thinking(type="enabled", budget_tokens=result or 0)
+        return llm_param.Thinking(type="enabled", budget_tokens=result)
     except KeyboardInterrupt:
         return None
 

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/config/select_model.py

@@ -108,60 +108,70 @@ def select_model_from_config(preferred: str | None = None) -> str | None:
         return None
 
     try:
-        import questionary
+        from prompt_toolkit.styles import Style
 
-        choices: list[questionary.Choice] = []
+        from klaude_code.ui.terminal.selector import SelectItem, select_one
 
         max_model_name_length = max(len(m.model_name) for m in filtered_models)
 
-        # Build model_id with thinking suffix as a single unit
-        def build_model_id_with_thinking(m: ModelEntry) -> str:
-            model_id = m.model_params.model or "N/A"
+        def _thinking_info(m: ModelEntry) -> str:
             thinking = m.model_params.thinking
-            if thinking:
-                if thinking.reasoning_effort:
-                    return f"{model_id} ({thinking.reasoning_effort})"
-                elif thinking.budget_tokens:
-                    return f"{model_id} (think {thinking.budget_tokens})"
-            return model_id
-
-        model_id_with_thinking = {m.model_name: build_model_id_with_thinking(m) for m in filtered_models}
-        max_model_id_length = max(len(v) for v in model_id_with_thinking.values())
-
+            if not thinking:
+                return ""
+            if thinking.reasoning_effort:
+                return f"reasoning effort {thinking.reasoning_effort}"
+            if thinking.budget_tokens:
+                return f"thinking budget {thinking.budget_tokens}"
+            return "thinking (configured)"
+
+        items: list[SelectItem[str]] = []
         for m in filtered_models:
-            star = "★ " if m.model_name == config.main_model else "  "
-            model_id_str = model_id_with_thinking[m.model_name]
-            title = f"{star}{m.model_name:<{max_model_name_length}}   →  {model_id_str:<{max_model_id_length}} @ {m.provider}"
-            choices.append(questionary.Choice(title=title, value=m.model_name))
+            model_id = m.model_params.model or "N/A"
+            first_line_prefix = f"{m.model_name:<{max_model_name_length}}  → "
+            thinking_info = _thinking_info(m)
+            meta_parts = [m.provider]
+            if thinking_info:
+                meta_parts.append(thinking_info)
+            if m.model_params.verbosity:
+                meta_parts.append(f"verbosity {m.model_params.verbosity}")
+            meta_line = "   " + " · ".join(meta_parts)
+            title = [
+                ("class:msg", first_line_prefix),
+                ("class:msg bold", f"{model_id}\n"),
+                ("class:meta", f"{meta_line}\n\n"),
+            ]
+            search_text = f"{m.model_name} {model_id} {m.provider}"
+            items.append(SelectItem(title=title, value=m.model_name, search_text=search_text))
 
         try:
             message = f"Select a model (filtered by '{preferred}'):" if preferred else "Select a model:"
-            result = questionary.select(
+            result = select_one(
                 message=message,
-                choices=choices,
+                items=items,
                 pointer="→",
-                instruction="↑↓ to move • Enter to select",
-                use_jk_keys=False,
                 use_search_filter=True,
-                style=questionary.Style(
+                initial_value=config.main_model,
+                style=Style(
                     [
-                        ("instruction", "ansibrightblack"),
-                        ("pointer", "ansicyan"),
-                        ("highlighted", "ansicyan"),
+                        ("pointer", "ansigreen"),
+                        ("highlighted", "ansigreen"),
+                        ("msg", ""),
+                        ("meta", "fg:ansibrightblack"),
                         ("text", "ansibrightblack"),
+                        ("question", ""),
+                        ("search_prefix", "ansibrightblack"),
                         # search filter colors at the bottom
                         ("search_success", "noinherit fg:ansigreen"),
                         ("search_none", "noinherit fg:ansired"),
-                        ("question-mark", "fg:ansigreen"),
                     ]
                 ),
-            ).ask()
+            )
             if isinstance(result, str) and result in names:
                 return result
         except KeyboardInterrupt:
             return None
     except Exception as e:
-        log((f"Failed to use questionary for model selection: {e}", "yellow"))
+        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 isinstance(preferred, str) and preferred in names:

klaude_code-1.4.0/src/klaude_code/session/selector.py

@@ -0,0 +1,98 @@
+import time
+
+from klaude_code.trace import log, log_debug
+from klaude_code.ui.terminal.selector import SelectItem, select_one
+
+from .session import Session
+
+
+def _relative_time(ts: float) -> str:
+    """Format timestamp as relative time like '5 days ago'."""
+    now = time.time()
+    diff = now - ts
+
+    if diff < 60:
+        return "just now"
+    elif diff < 3600:
+        mins = int(diff / 60)
+        return f"{mins} minute{'s' if mins != 1 else ''} ago"
+    elif diff < 86400:
+        hours = int(diff / 3600)
+        return f"{hours} hour{'s' if hours != 1 else ''} ago"
+    elif diff < 604800:
+        days = int(diff / 86400)
+        return f"{days} day{'s' if days != 1 else ''} ago"
+    elif diff < 2592000:
+        weeks = int(diff / 604800)
+        return f"{weeks} week{'s' if weeks != 1 else ''} ago"
+    else:
+        months = int(diff / 2592000)
+        return f"{months} month{'s' if months != 1 else ''} ago"
+
+
+def resume_select_session() -> str | None:
+    sessions = Session.list_sessions()
+    if not sessions:
+        log("No sessions found for this project.")
+        return None
+
+    try:
+        from prompt_toolkit.styles import Style
+
+        items: list[SelectItem[str]] = []
+        for s in sessions:
+            first_msg = s.first_user_message or "N/A"
+            first_msg = first_msg.strip().replace("\n", " ")
+
+            msg_count = "N/A" if s.messages_count == -1 else f"{s.messages_count} messages"
+            model = s.model_name or "N/A"
+
+            title = [
+                ("class:msg", f"{first_msg}\n"),
+                ("class:meta", f"   {msg_count} · {_relative_time(s.updated_at)} · {model} · {s.id}\n\n"),
+            ]
+            items.append(
+                SelectItem(
+                    title=title,
+                    value=str(s.id),
+                    search_text=f"{first_msg} {model} {s.id}",
+                )
+            )
+
+        return select_one(
+            message="Select a session to resume:",
+            items=items,
+            pointer="→",
+            style=Style(
+                [
+                    ("msg", ""),
+                    ("meta", "fg:ansibrightblack"),
+                    ("pointer", "bold fg:ansigreen"),
+                    ("highlighted", "fg:ansigreen"),
+                    ("search_prefix", "fg:ansibrightblack"),
+                    ("search_success", "noinherit fg:ansigreen"),
+                    ("search_none", "noinherit fg:ansired"),
+                    ("question", "bold"),
+                    ("text", ""),
+                ]
+            ),
+        )
+    except Exception as e:
+        log_debug(f"Failed to use prompt_toolkit for session select, {e}")
+
+        for i, s in enumerate(sessions, 1):
+            first_msg = (s.first_user_message or "N/A").strip().replace("\n", " ")
+            if len(first_msg) > 60:
+                first_msg = first_msg[:59] + "…"
+            msg_count = "N/A" if s.messages_count == -1 else f"{s.messages_count} msgs"
+            model = s.model_name or "N/A"
+            print(f"{i}. {first_msg}")
+            print(f"   {_relative_time(s.updated_at)} · {msg_count} · {model}")
+        try:
+            raw = input("Select a session number: ").strip()
+            idx = int(raw)
+            if 1 <= idx <= len(sessions):
+                return str(sessions[idx - 1].id)
+        except (ValueError, EOFError):
+            return None
+    return None

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/ui/modes/repl/event_handler.py

@@ -12,6 +12,7 @@ from klaude_code.ui.core.stage_manager import Stage, StageManager
 from klaude_code.ui.modes.repl.renderer import REPLRenderer
 from klaude_code.ui.renderers.assistant import ASSISTANT_MESSAGE_MARK
 from klaude_code.ui.renderers.thinking import THINKING_MESSAGE_MARK, normalize_thinking_content
+from klaude_code.ui.rich import status as r_status
 from klaude_code.ui.rich.markdown import MarkdownStream, ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.terminal.notifier import Notification, NotificationType, TerminalNotifier
@@ -352,6 +353,8 @@ class DisplayEventHandler:
         self.renderer.display_user_message(event)
 
     def _on_task_start(self, event: events.TaskStartEvent) -> None:
+        if event.sub_agent_state is None:
+            r_status.set_task_start()
         self.renderer.spinner_start()
         self.renderer.display_task_start(event)
         emit_osc94(OSC94States.INDETERMINATE)
@@ -501,6 +504,7 @@ class DisplayEventHandler:
     async def _on_task_finish(self, event: events.TaskFinishEvent) -> None:
         self.renderer.display_task_finish(event)
         if not self.renderer.is_sub_agent_session(event.session_id):
+            r_status.clear_task_start()
             emit_osc94(OSC94States.HIDDEN)
             self.spinner_status.reset()
             self.renderer.spinner_stop()
@@ -511,6 +515,7 @@ class DisplayEventHandler:
     async def _on_interrupt(self, event: events.InterruptEvent) -> None:
         self.renderer.spinner_stop()
         self.spinner_status.reset()
+        r_status.clear_task_start()
         await self.stage_manager.transition_to(Stage.WAITING)
         emit_osc94(OSC94States.HIDDEN)
         self.renderer.display_interrupt()
@@ -528,6 +533,7 @@ class DisplayEventHandler:
         await self.stage_manager.transition_to(Stage.WAITING)
         self.renderer.spinner_stop()
         self.spinner_status.reset()
+        r_status.clear_task_start()
 
     # ─────────────────────────────────────────────────────────────────────────────
     # Private helper methods
@@ -619,7 +625,7 @@ class DisplayEventHandler:
         # 1 cell for glyph + 1 cell of padding between columns (collapsed).
         spinner_prefix_cells = 2
 
-        hint_cells = cell_len(const.STATUS_HINT_TEXT)
+        hint_cells = cell_len(r_status.current_hint_text())
         right_cells = cell_len(right_text.plain) if right_text is not None else 0
 
         max_main_cells = terminal_width - spinner_prefix_cells - hint_cells - right_cells - 1

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/ui/modes/repl/input_prompt_toolkit.py

@@ -55,7 +55,7 @@ class PromptToolkitInput(InputProviderABC):
         self._pre_prompt = pre_prompt
         self._post_prompt = post_prompt
         # Use provided value if available to avoid redundant TTY queries that may interfere
-        # with prompt_toolkit's terminal state after questionary has been used.
+        # with prompt_toolkit's terminal state after interactive UIs have been used.
         self._is_light_terminal_background = (
             is_light_background if is_light_background is not None else is_light_terminal_background(timeout=0.2)
         )

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/ui/modes/repl/key_bindings.py

@@ -34,6 +34,47 @@ def create_key_bindings(
     """
     kb = KeyBindings()
 
+    def _should_submit_instead_of_accepting_completion(buf: Buffer) -> bool:
+        """Return True when Enter should submit even if completions are visible.
+
+        We show completions proactively for contexts like `/`.
+        If the user already typed an exact candidate (e.g. `/clear`), accepting
+        a completion often only adds a trailing space and makes Enter require
+        two presses. In that case, prefer submitting.
+        """
+        state = buf.complete_state
+        if state is None or not state.completions:
+            return False
+
+        try:
+            doc = buf.document  # type: ignore[reportUnknownMemberType]
+            text = cast(str, doc.text)  # type: ignore[reportUnknownMemberType]
+            cursor_pos = cast(int, doc.cursor_position)  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            return False
+
+        # Only apply this heuristic when the caret is at the end of the buffer.
+        if cursor_pos != len(text):
+            return False
+
+        for completion in state.completions:
+            try:
+                start = cursor_pos + completion.start_position
+                if start < 0 or start > cursor_pos:
+                    continue
+
+                replaced = text[start:cursor_pos]
+                inserted = completion.text
+
+                # If the user already typed an exact candidate, don't force
+                # accepting a completion (which often just adds a space).
+                if replaced == inserted or replaced == inserted.rstrip():
+                    return True
+            except Exception:
+                continue
+
+        return False
+
     def _select_first_completion_if_needed(buf: Buffer) -> None:
         """Ensure the completion menu has an active selection.
 
@@ -98,7 +139,7 @@ def create_key_bindings(
         # When completions are visible, Enter accepts the current selection.
         # This aligns with common TUI completion UX: navigation doesn't modify
         # the buffer, and Enter/Tab inserts the selected option.
-        if _accept_current_completion(buf):
+        if not _should_submit_instead_of_accepting_completion(buf) and _accept_current_completion(buf):
             return
 
         # If the entire buffer is whitespace-only, insert a newline rather than submitting.

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/ui/renderers/developer.py

@@ -67,23 +67,32 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
 
     if e.item.at_files:
         grid = create_grid()
+        # Group at_files by (operation, mentioned_in)
+        grouped: dict[tuple[str, str | None], list[str]] = {}
         for at_file in e.item.at_files:
-            if at_file.mentioned_in:
+            key = (at_file.operation, at_file.mentioned_in)
+            if key not in grouped:
+                grouped[key] = []
+            grouped[key].append(at_file.path)
+
+        for (operation, mentioned_in), paths in grouped.items():
+            path_texts = Text(", ", ThemeKey.REMINDER).join(render_path(p, ThemeKey.REMINDER_BOLD) for p in paths)
+            if mentioned_in:
                 grid.add_row(
                     Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
                     Text.assemble(
-                        (f"{at_file.operation} ", ThemeKey.REMINDER),
-                        render_path(at_file.path, ThemeKey.REMINDER_BOLD),
+                        (f"{operation} ", ThemeKey.REMINDER),
+                        path_texts,
                         (" mentioned in ", ThemeKey.REMINDER),
-                        render_path(at_file.mentioned_in, ThemeKey.REMINDER_BOLD),
+                        render_path(mentioned_in, ThemeKey.REMINDER_BOLD),
                     ),
                 )
             else:
                 grid.add_row(
                     Text(REMINDER_BULLET, style=ThemeKey.REMINDER),
                     Text.assemble(
-                        (f"{at_file.operation} ", ThemeKey.REMINDER),
-                        render_path(at_file.path, ThemeKey.REMINDER_BOLD),
+                        (f"{operation} ", ThemeKey.REMINDER),
+                        path_texts,
                     ),
                 )
         parts.append(grid)

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/ui/renderers/errors.py

@@ -17,5 +17,5 @@ def render_tool_error(error_msg: Text) -> RenderableType:
     """Render error with indent for tool results."""
     grid = create_grid()
     error_msg.style = ThemeKey.ERROR
-    grid.add_row(Text("  "), error_msg)
+    grid.add_row(Text(" "), error_msg)
     return grid

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/ui/renderers/tools.py

@@ -27,7 +27,7 @@ MARK_PLAN = "◈"
 MARK_READ = "→"
 MARK_EDIT = "±"
 MARK_WRITE = "+"
-MARK_MOVE = "⤭"
+MARK_MOVE = "±"
 MARK_MERMAID = "⧉"
 MARK_WEB_FETCH = "→"
 MARK_WEB_SEARCH = "✱"

{klaude_code-1.3.0 → klaude_code-1.4.0}/src/klaude_code/ui/rich/searchable_text.py

@@ -6,9 +6,7 @@ from collections.abc import Iterable, Sequence
 class SearchableFormattedText:
     """
     Wrapper for prompt_toolkit formatted text that also supports string-like
-    methods used by questionary's search filter (e.g., ``.lower()``).
-
-    This allows using ``use_search_filter=True`` with a formatted ``Choice.title``.
+    methods commonly expected by search filters (e.g., ``.lower()``).
 
     - ``fragments``: A sequence of (style, text) tuples accepted by
       prompt_toolkit's ``to_formatted_text``.
@@ -32,7 +30,7 @@ class SearchableFormattedText:
     def __str__(self) -> str:  # pragma: no cover - utility
         return self._plain
 
-    # Minimal string API to satisfy questionary's search filter logic.
+    # Minimal string API for search filtering.
     def lower(self) -> str:
         return self._plain.lower()
 
@@ -47,10 +45,9 @@ class SearchableFormattedText:
 
 class SearchableFormattedList(list[tuple[str, str]]):
     """
-    List variant compatible with questionary's expected ``Choice.title`` type.
+    List variant compatible with prompt_toolkit formatted-text usage.
 
-    - Behaves like ``List[Tuple[str, str]]`` for rendering (so ``isinstance(..., list)`` works),
-      preserving existing styling behavior in questionary.
+    - Behaves like ``List[Tuple[str, str]]`` for rendering (so ``isinstance(..., list)`` works).
     - Provides ``.lower()``/``.upper()`` returning the plain text for search filtering.
     """