klaude-code 1.3.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

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/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/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/command/thinking_cmd.py

@@ -1,9 +1,13 @@
 import asyncio
+from typing import Literal, cast
 
-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
+
+ReasoningEffort = Literal["high", "medium", "low", "minimal", "none", "xhigh"]
 
 # Thinking level options for different protocols
 RESPONSES_LEVELS = ["low", "medium", "high"]
@@ -118,12 +122,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,43 +136,46 @@ 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
-        return llm_param.Thinking(reasoning_effort=result)
+        return llm_param.Thinking(reasoning_effort=cast(ReasoningEffort, result))
     except KeyboardInterrupt:
         return None
 
 
 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/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 {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: list[str] = [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_str = " · ".join(meta_parts)
+            title = [
+                ("class:msg", first_line_prefix),
+                ("class:msg bold", model_id),
+                ("class:meta", f"  {meta_str}\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", "bold"),
+                        ("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/core/tool/__init__.py

@@ -1,7 +1,7 @@
 from .file.apply_patch import DiffError, process_patch
 from .file.apply_patch_tool import ApplyPatchTool
-from .file.move_tool import MoveTool
 from .file.edit_tool import EditTool
+from .file.move_tool import MoveTool
 from .file.read_tool import ReadTool
 from .file.write_tool import WriteTool
 from .report_back_tool import ReportBackTool
@@ -32,11 +32,11 @@ from .web.web_search_tool import WebSearchTool
 __all__ = [
     "ApplyPatchTool",
     "BashTool",
-    "MoveTool",
     "DiffError",
     "EditTool",
     "FileTracker",
     "MermaidTool",
+    "MoveTool",
     "ReadTool",
     "ReportBackTool",
     "SafetyCheckResult",

klaude_code/session/selector.py

@@ -1,76 +1,93 @@
 import time
-from typing import TYPE_CHECKING
 
 from klaude_code.trace import log, log_debug
-
-if TYPE_CHECKING:
-    from questionary import Choice
+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:
-    # Column widths
-    UPDATED_AT_WIDTH = 16
-    MSG_COUNT_WIDTH = 3
-    MODEL_WIDTH = 25
-    FIRST_MESSAGE_WIDTH = 50
     sessions = Session.list_sessions()
     if not sessions:
         log("No sessions found for this project.")
         return None
 
-    def _fmt(ts: float) -> str:
-        try:
-            return time.strftime("%m-%d %H:%M:%S", time.localtime(ts))
-        except (ValueError, OSError):
-            return str(ts)
-
     try:
-        import questionary
+        from prompt_toolkit.styles import Style
 
-        choices: list[Choice] = []
+        items: list[SelectItem[str]] = []
         for s in sessions:
-            first_user_message = s.first_user_message or "N/A"
-            msg_count_display = "N/A" if s.messages_count == -1 else str(s.messages_count)
-            model_display = s.model_name or "N/A"
+            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:d", f"{_fmt(s.updated_at):<{UPDATED_AT_WIDTH}} "),
-                ("class:b", f"{msg_count_display:>{MSG_COUNT_WIDTH}}  "),
-                (
-                    "class:t",
-                    f"{model_display[: MODEL_WIDTH - 1] + '…' if len(model_display) > MODEL_WIDTH else model_display:<{MODEL_WIDTH}}  ",
-                ),
-                (
-                    "class:t",
-                    f"{first_user_message.strip().replace('\n', ' ↩ '):<{FIRST_MESSAGE_WIDTH}}",
-                ),
+                ("class:msg", f"{first_msg}\n"),
+                ("class:meta", f"   {msg_count} · {_relative_time(s.updated_at)} · {model} · {s.id}\n\n"),
             ]
-            choices.append(questionary.Choice(title=title, value=s.id))
-        return questionary.select(
-            message=f"{' Updated at':<{UPDATED_AT_WIDTH + 1}} {'Msg':>{MSG_COUNT_WIDTH}}  {'Model':<{MODEL_WIDTH}}  {'First message':<{FIRST_MESSAGE_WIDTH}}",
-            choices=choices,
+            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="→",
-            instruction="↑↓ to move",
-            style=questionary.Style(
+            style=Style(
                 [
-                    ("t", ""),
-                    ("b", "bold"),
-                    ("d", "dim"),
+                    ("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", ""),
                 ]
             ),
-        ).ask()
+        )
     except Exception as e:
-        log_debug(f"Failed to use questionary for session select, {e}")
+        log_debug(f"Failed to use prompt_toolkit for session select, {e}")
 
         for i, s in enumerate(sessions, 1):
-            msg_count_display = "N/A" if s.messages_count == -1 else str(s.messages_count)
-            model_display = s.model_name or "N/A"
-            print(
-                f"{i}. {_fmt(s.updated_at)}  {msg_count_display:>{MSG_COUNT_WIDTH}} "
-                f"{model_display[: MODEL_WIDTH - 1] + '…' if len(model_display) > MODEL_WIDTH else model_display:<{MODEL_WIDTH}} {s.id}  {s.work_dir}"
-            )
+            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)

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/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/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/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/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/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/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.
     """
 

klaude_code/ui/rich/status.py

@@ -31,6 +31,7 @@ random.shuffle(BREATHING_SPINNER_GLYPHS)
 
 
 _process_start: float | None = None
+_task_start: float | None = None
 
 
 def _elapsed_since_start() -> float:
@@ -42,6 +43,59 @@ def _elapsed_since_start() -> float:
     return now - _process_start
 
 
+def set_task_start(start: float | None = None) -> None:
+    """Set the current task start time (perf_counter seconds)."""
+
+    global _task_start
+    _task_start = time.perf_counter() if start is None else start
+
+
+def clear_task_start() -> None:
+    """Clear the current task start time."""
+
+    global _task_start
+    _task_start = None
+
+
+def _task_elapsed_seconds(now: float | None = None) -> float | None:
+    if _task_start is None:
+        return None
+    current = time.perf_counter() if now is None else now
+    return max(0.0, current - _task_start)
+
+
+def _format_elapsed_compact(seconds: float) -> str:
+    total_seconds = max(0, int(seconds))
+    if total_seconds < 60:
+        return f"{total_seconds}s"
+
+    minutes, sec = divmod(total_seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m{sec:02d}s"
+
+    hours, minute = divmod(minutes, 60)
+    return f"{hours}h{minute:02d}m{sec:02d}s"
+
+
+def current_hint_text(*, min_time_width: int = 0) -> str:
+    """Return the full hint string shown on the status line.
+
+    Includes an optional elapsed time prefix (right-aligned, min width) and
+    the constant hint suffix.
+    """
+
+    elapsed = _task_elapsed_seconds()
+    if elapsed is None:
+        return const.STATUS_HINT_TEXT
+    time_text = _format_elapsed_compact(elapsed)
+    if min_time_width > 0:
+        time_text = time_text.rjust(min_time_width)
+    suffix = const.STATUS_HINT_TEXT.strip()
+    if suffix.startswith("(") and suffix.endswith(")"):
+        suffix = suffix[1:-1]
+    return f" ({time_text} · {suffix})"
+
+
 def _shimmer_profile(main_text: str) -> list[tuple[str, float]]:
     """Compute per-character shimmer intensity for a horizontal band.
 
@@ -176,7 +230,6 @@ class ShimmerStatusText:
             self._main_text = text
         else:
             self._main_text = Text(main_text, style=main_style)
-        self._hint_text = Text(const.STATUS_HINT_TEXT)
         self._hint_style = ThemeKey.STATUS_HINT
         self._right_text = right_text
 
@@ -206,7 +259,7 @@ class ShimmerStatusText:
             result.append(ch, style=style)
 
         # Append hint text without shimmer
-        result.append(self._hint_text.plain, style=hint_style)
+        result.append(current_hint_text().strip("\n"), style=hint_style)
 
         return result
 

klaude_code/ui/terminal/selector.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import contextlib
+import sys
+from dataclasses import dataclass
+from functools import partial
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.filters import Always, Condition
+from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent, merge_key_bindings
+from prompt_toolkit.key_binding.defaults import load_key_bindings
+from prompt_toolkit.keys import Keys
+from prompt_toolkit.layout import ConditionalContainer, Float, FloatContainer, HSplit, Layout, VSplit, Window
+from prompt_toolkit.layout.containers import Container, ScrollOffsets
+from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
+from prompt_toolkit.styles import Style, merge_styles
+
+
+@dataclass(frozen=True, slots=True)
+class SelectItem[T]:
+    """One selectable item for terminal selection UI."""
+
+    title: list[tuple[str, str]]
+    value: T
+    search_text: str
+
+
+def select_one[T](
+    *,
+    message: str,
+    items: list[SelectItem[T]],
+    pointer: str = "→",
+    style: Style | None = None,
+    use_search_filter: bool = True,
+    initial_value: T | None = None,
+    search_placeholder: str = "type to search",
+) -> T | None:
+    """Terminal single-choice selector based on prompt_toolkit.
+
+    Features:
+    - Search-as-you-type filter (optional)
+    - Multi-line titles (via formatted text fragments)
+    - Highlight entire pointed item via `class:highlighted`
+    """
+
+    if not items:
+        return None
+
+    # Non-interactive environments should not enter an interactive prompt.
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        return None
+
+    pointed_at = 0
+
+    search_buffer: Buffer | None = None
+    if use_search_filter:
+        search_buffer = Buffer()
+
+    def visible_indices() -> tuple[list[int], bool]:
+        filter_text = search_buffer.text if (use_search_filter and search_buffer is not None) else ""
+        if not filter_text:
+            return list(range(len(items))), True
+
+        needle = filter_text.lower()
+        matched = [i for i, it in enumerate(items) if needle in it.search_text.lower()]
+        if matched:
+            return matched, True
+        return list(range(len(items))), False
+
+    def _restyle_title(title: list[tuple[str, str]], cls: str) -> list[tuple[str, str]]:
+        # Keep simple text attributes like bold/italic while overriding colors via `cls`.
+        keep_attrs = {"bold", "italic", "underline", "reverse", "blink", "strike"}
+        restyled: list[tuple[str, str]] = []
+        for old_style, text in title:
+            attrs = [tok for tok in old_style.split() if tok in keep_attrs]
+            style = f"{cls} {' '.join(attrs)}".strip()
+            restyled.append((style, text))
+        return restyled
+
+    def get_header_tokens() -> list[tuple[str, str]]:
+        return [("class:question", message + " ")]
+
+    def get_choices_tokens() -> list[tuple[str, str]]:
+        nonlocal pointed_at
+        indices, _found = visible_indices()
+        if not indices:
+            return [("class:text", "(no items)\n")]
+
+        pointed_at %= len(indices)
+        tokens: list[tuple[str, str]] = []
+
+        pointer_pad = " " * (2 + len(pointer))
+        pointed_prefix = f" {pointer} "
+
+        for pos, idx in enumerate(indices):
+            is_pointed = pos == pointed_at
+
+            if is_pointed:
+                tokens.append(("class:pointer", pointed_prefix))
+                tokens.append(("[SetCursorPosition]", ""))
+            else:
+                tokens.append(("class:text", pointer_pad))
+
+            title_tokens = _restyle_title(items[idx].title, "class:highlighted") if is_pointed else items[idx].title
+            tokens.extend(title_tokens)
+
+        return tokens
+
+    def _on_search_changed(_buf: Buffer) -> None:
+        nonlocal pointed_at
+        pointed_at = 0
+        with contextlib.suppress(Exception):
+            get_app().invalidate()
+
+    kb = KeyBindings()
+
+    @kb.add(Keys.ControlC, eager=True)
+    @kb.add(Keys.ControlQ, eager=True)
+    def _cancel(event: KeyPressEvent) -> None:
+        event.app.exit(result=None)
+
+    _ = _cancel  # registered via decorator
+
+    @kb.add(Keys.Down, eager=True)
+    def _down(event: KeyPressEvent) -> None:
+        nonlocal pointed_at
+        pointed_at += 1
+        event.app.invalidate()
+
+    _ = _down  # registered via decorator
+
+    @kb.add(Keys.Up, eager=True)
+    def _up(event: KeyPressEvent) -> None:
+        nonlocal pointed_at
+        pointed_at -= 1
+        event.app.invalidate()
+
+    _ = _up  # registered via decorator
+
+    @kb.add(Keys.Enter, eager=True)
+    def _enter(event: KeyPressEvent) -> None:
+        indices, _ = visible_indices()
+        if not indices:
+            event.app.exit(result=None)
+            return
+        idx = indices[pointed_at % len(indices)]
+        event.app.exit(result=items[idx].value)
+
+    _ = _enter  # registered via decorator
+
+    @kb.add(Keys.Escape, eager=True)
+    def _esc(event: KeyPressEvent) -> None:
+        nonlocal pointed_at
+        if use_search_filter and search_buffer is not None and search_buffer.text:
+            search_buffer.reset(append_to_history=False)
+            pointed_at = 0
+            event.app.invalidate()
+            return
+        event.app.exit(result=None)
+
+    _ = _esc  # registered via decorator
+
+    if use_search_filter and search_buffer is not None:
+        search_buffer.on_text_changed += _on_search_changed
+
+    if initial_value is not None:
+        try:
+            full_index = next(i for i, it in enumerate(items) if it.value == initial_value)
+            indices, _ = visible_indices()
+            pointed_at = indices.index(full_index) if full_index in indices else 0
+        except StopIteration:
+            pointed_at = 0
+
+    header_window = Window(
+        FormattedTextControl(get_header_tokens),
+        height=1,
+        dont_extend_height=Always(),
+        always_hide_cursor=Always(),
+    )
+    spacer_window = Window(
+        FormattedTextControl([("", "")]),
+        height=1,
+        dont_extend_height=Always(),
+        always_hide_cursor=Always(),
+    )
+    list_window = Window(
+        FormattedTextControl(get_choices_tokens),
+        scroll_offsets=ScrollOffsets(top=0, bottom=2),
+        allow_scroll_beyond_bottom=True,
+        dont_extend_height=Always(),
+        always_hide_cursor=Always(),
+    )
+
+    search_container = None
+    search_input_window: Window | None = None
+    if use_search_filter and search_buffer is not None:
+        placeholder_text = f"{search_placeholder} · ↑↓ to select"
+
+        search_prefix_window = Window(
+            FormattedTextControl([("class:search_prefix", "/ ")]),
+            width=2,
+            height=1,
+            dont_extend_height=Always(),
+            always_hide_cursor=Always(),
+        )
+        input_window = Window(
+            BufferControl(buffer=search_buffer),
+            height=1,
+            dont_extend_height=Always(),
+            style="class:search_input",
+        )
+        placeholder_window = ConditionalContainer(
+            content=Window(
+                FormattedTextControl([("class:search_placeholder", placeholder_text)]),
+                height=1,
+                dont_extend_height=Always(),
+                always_hide_cursor=Always(),
+            ),
+            filter=Condition(lambda: search_buffer.text == ""),
+        )
+        search_input_window = input_window
+        search_input_container = FloatContainer(
+            content=input_window,
+            floats=[Float(content=placeholder_window, top=0, left=0)],
+        )
+
+        def _rounded_frame(body: Container) -> HSplit:
+            border = partial(Window, style="class:frame.border", height=1)
+            top = VSplit(
+                [
+                    border(width=1, char="╭"),
+                    border(char="─"),
+                    border(width=1, char="╮"),
+                ],
+                height=1,
+                padding=0,
+            )
+            middle = VSplit(
+                [
+                    border(width=1, char="│"),
+                    body,
+                    border(width=1, char="│"),
+                ],
+                padding=0,
+            )
+            bottom = VSplit(
+                [
+                    border(width=1, char="╰"),
+                    border(char="─"),
+                    border(width=1, char="╯"),
+                ],
+                height=1,
+                padding=0,
+            )
+            return HSplit([top, middle, bottom], padding=0, style="class:frame")
+
+        search_container = _rounded_frame(VSplit([search_prefix_window, search_input_container], padding=0))
+
+    base_style = Style(
+        [
+            ("frame.border", "fg:ansibrightblack"),
+            ("frame.label", "fg:ansibrightblack italic"),
+            ("search_prefix", "fg:ansibrightblack"),
+            ("search_placeholder", "fg:ansibrightblack italic"),
+        ]
+    )
+    merged_style = merge_styles([base_style, style] if style is not None else [base_style])
+
+    root_children: list[Container] = [header_window, spacer_window, list_window]
+    if search_container is not None:
+        root_children.append(search_container)
+
+    app: Application[T | None] = Application(
+        layout=Layout(HSplit(root_children), focused_element=search_input_window or list_window),
+        key_bindings=merge_key_bindings([load_key_bindings(), kb]),
+        style=merged_style,
+        mouse_support=False,
+        full_screen=False,
+        erase_when_done=True,
+    )
+    return app.run()

{klaude_code-1.3.0.dist-info → klaude_code-1.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.3.0
+Version: 1.4.1
 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.dist-info → klaude_code-1.4.1.dist-info}/RECORD

@@ -11,9 +11,9 @@ klaude_code/cli/config_cmd.py,sha256=hlvslLNgdRHkokq1Pnam0XOdR3jqO3K0vNLqtWnPa6Q
 klaude_code/cli/debug.py,sha256=cPQ7cgATcJTyBIboleW_Q4Pa_t-tGG6x-Hj3woeeuHE,2669
 klaude_code/cli/list_model.py,sha256=uA0PNR1RjUK7BCKu2Q0Sh2xB9j9Gpwp_bsWhroTW6JY,9260
 klaude_code/cli/main.py,sha256=td_nMg0AyFDdyh3TLi7WCpi9DyAehduI4jZSOAaCNXI,12857
-klaude_code/cli/runtime.py,sha256=EGlfr839OWAJjLSfYHnTxwG7W-IxkmktgDOj8npKkFo,15219
+klaude_code/cli/runtime.py,sha256=9PbyCiyaSm3wQZViIMOgJRNnjgLLIkCkQrDcn8yMn1E,15190
 klaude_code/cli/self_update.py,sha256=iGuj0i869Zi0M70W52-VVLxZp90ISr30fQpZkHGMK2o,8059
-klaude_code/cli/session_cmd.py,sha256=mVL2fDi76nmpK2bWYrU7Wh6jCi90A9YK8hv3UNo4GI0,2661
+klaude_code/cli/session_cmd.py,sha256=q2YarlV6KARkFnbm_36ZUvBh8Noj8B7TlMg1RIlt1GE,3154
 klaude_code/command/__init__.py,sha256=hN239WtGddSsln7qF-VMJZw1FNOTb1gBikWZrzfoC9M,3366
 klaude_code/command/clear_cmd.py,sha256=3Ru6pFmOwru06XTLTuEGNUhKgy3COOaNe22Dk0TpGrQ,719
 klaude_code/command/command_abc.py,sha256=wZl_azY6Dpd4OvjtkSEPI3ilXaygLIVkO7NCgNlrofQ,2536
@@ -22,7 +22,7 @@ klaude_code/command/export_cmd.py,sha256=Cs7YXWtos-ZfN9OEppIl8Xrb017kDG7R6hGiilq
 klaude_code/command/export_online_cmd.py,sha256=RYYLnkLtg6edsgysmhsfTw16ncFRIT6PqeTdWhWXLHE,6094
 klaude_code/command/fork_session_cmd.py,sha256=T3o0mOVcqL2Ts39Ijl4t2Sl0GYbvh8zyd9z21M-AThU,1682
 klaude_code/command/help_cmd.py,sha256=yQJnVtj6sgXQdGsi4u9aS7EcjJLSrXccUA-v_bqmsRw,1633
-klaude_code/command/model_cmd.py,sha256=xnBMB9odyX4SZTerbkG01HNc3wlPLzoB57AZJr0vCmc,2935
+klaude_code/command/model_cmd.py,sha256=Ff-2tkvpdnnSoCN98FUjHMtoA2qk1PNNkhzZlW22HAk,3053
 klaude_code/command/prompt-init.md,sha256=a4_FQ3gKizqs2vl9oEY5jtG6HNhv3f-1b5RSCFq0A18,1873
 klaude_code/command/prompt-jj-describe.md,sha256=n-7hiXU8oodCMR3ipNyRR86pAUzXMz6seloU9a6QQnY,974
 klaude_code/command/prompt_command.py,sha256=rMi-ZRLpUSt1t0IQVtwnzIYqcrXK-MwZrabbZ8dc8U4,2774
@@ -32,13 +32,13 @@ klaude_code/command/release_notes_cmd.py,sha256=FIrBRfKTlXEp8mBh15buNjgOrl_GMX7F
 klaude_code/command/resume_cmd.py,sha256=z5PNVZ_jzH-8YWPd0Qjj8mFwE8kjPSpM_GohExXL_QA,1970
 klaude_code/command/status_cmd.py,sha256=95cp4-Qg7ju4TZhKIV6_dfv1rrjcyNO6816NHtfk6v0,5413
 klaude_code/command/terminal_setup_cmd.py,sha256=SivM1gX_anGY_8DCQNFZ5VblFqt4sVgCMEWPRlo6K5w,10911
-klaude_code/command/thinking_cmd.py,sha256=8EdSN6huXihM5NHJEryZLA7CkgRT7mZgMVTJsT1-x8U,9108
+klaude_code/command/thinking_cmd.py,sha256=uip1Cvam2f9j44yyT57j8H5LjPeLP7mkRK3A5bmuAMU,9327
 klaude_code/config/__init__.py,sha256=Qe1BeMekBfO2-Zd30x33lB70hdM1QQZGrp4DbWSQ-II,353
 klaude_code/config/assets/__init__.py,sha256=uMUfmXT3I-gYiI-HVr1DrE60mx5cY1o8V7SYuGqOmvY,32
 klaude_code/config/assets/builtin_config.yaml,sha256=9sfpcVqY3uWVGSdyteH3P_B8ZDwPhfJAoT2Q5o7I1bk,5605
 klaude_code/config/builtin_config.py,sha256=RgbawLV4yKk1IhJsQn04RkitDyLLhCwTqQ3nJkdvHGI,1113
 klaude_code/config/config.py,sha256=rTMU-7IYl_fmthB4LsrCaSgUVttNSw7Agif8XRCmU1g,16331
-klaude_code/config/select_model.py,sha256=vj4Qs1cl9-u6ucAjDwDvoODmlplwdYo1U57jUcKPya4,7035
+klaude_code/config/select_model.py,sha256=0ON5O2ITBvyBNU80uEFQr65z2wbhdHtlzYLVTYx0AjA,7303
 klaude_code/const.py,sha256=Xc6UKku2sGQE05mvPNCpBbKK205vJrS9CaNAeKvu1AA,4612
 klaude_code/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 klaude_code/core/agent.py,sha256=bWm-UFX_0-KAy5j_YHH8X8o3MJT4-40Ni2EaDP2SL5k,5819
@@ -60,7 +60,7 @@ klaude_code/core/prompts/prompt-sub-agent-web.md,sha256=ewS7-h8_u4QZftFpqrZWpht9
 klaude_code/core/prompts/prompt-sub-agent.md,sha256=dmmdsOenbAOfqG6FmdR88spOLZkXmntDBs-cmZ9DN_g,897
 klaude_code/core/reminders.py,sha256=M_YPlOuZ2TpTjoxfEp1FbswB4yuk9_XUgSGb9MoMBCA,24741
 klaude_code/core/task.py,sha256=V0z-QSDSxB4d4mcqXl6z_KydG_yT0JhD7274AQbNGKM,11858
-klaude_code/core/tool/__init__.py,sha256=im3Tv1cE-H7PcVVZXaLD040U8O55cyoMyGlYo4Rp210,1992
+klaude_code/core/tool/__init__.py,sha256=Y1r-xka9Zk5e5SrB0kcweFp4LyH0aafQ-BDiwYCAqFY,1992
 klaude_code/core/tool/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 klaude_code/core/tool/file/_utils.py,sha256=OG4BE9WyJqzH8ilVCL3D9yvAcHk-r-L9snd-E8gO_io,967
 klaude_code/core/tool/file/apply_patch.py,sha256=LZd3pYQ9ow_TxiFnqYuzD216HmvkLX6lW6BoMd9iQRs,17080
@@ -141,7 +141,7 @@ klaude_code/protocol/tools.py,sha256=ejhMCBBMz1ODbPEiynhzjB-aLbIRKL-wipPFv-nEz4g
 klaude_code/session/__init__.py,sha256=oXcDA5w-gJCbzmlF8yuWy3ezIW9DgFBNUs-gJHUJ-Rc,121
 klaude_code/session/codec.py,sha256=ummbqT7t6uHHXtaS9lOkyhi1h0YpMk7SNSms8DyGAHU,2015
 klaude_code/session/export.py,sha256=dj-IRUNtXL8uONDj9bsEXcEHKyeHY7lIcXv80yP88h4,31022
-klaude_code/session/selector.py,sha256=uJQTQAw1ce9LzNOswSFEPkB7_PTzoJRXbA9rwK8hvdQ,2913
+klaude_code/session/selector.py,sha256=T4CUAJ6trrN14W9jXm1rnVMuoetKtn3FZoQhftnxBoo,3409
 klaude_code/session/session.py,sha256=otWpPnCk5LGS5IW_zTdeXBtLdxbBlEK2jH5FnrOIpF4,16969
 klaude_code/session/store.py,sha256=-e-lInCB3N1nFLlet7bipkmPk1PXmGthuMxv5z3hg5o,6953
 klaude_code/session/templates/export_session.html,sha256=bA27AkcC7DQRoWmcMBeaR8WOx1z76hezEDf0aYH-0HQ,119780
@@ -171,22 +171,22 @@ klaude_code/ui/modes/repl/__init__.py,sha256=_0II73jlz5JUtvJsZ9sGRJzeHIQyJJpaI0e
 klaude_code/ui/modes/repl/clipboard.py,sha256=ZCpk7kRSXGhh0Q_BWtUUuSYT7ZOqRjAoRcg9T9n48Wo,5137
 klaude_code/ui/modes/repl/completers.py,sha256=AElBFnWculNsSadom7ScnKf-P_vilC4V5AUn2qpRkXE,30005
 klaude_code/ui/modes/repl/display.py,sha256=06wawOHWO2ItEA9EIEh97p3GDID7TJhAtpaA03nPQXs,2335
-klaude_code/ui/modes/repl/event_handler.py,sha256=2b4KBhprfDw8MVYDz7MzKV_lOgfHihPZ8Ae1ewqVgBM,25777
-klaude_code/ui/modes/repl/input_prompt_toolkit.py,sha256=8P3i9Q8DljSOmVJVjlMlWx0aeyp1iPBhcmi0RWAl_go,8762
-klaude_code/ui/modes/repl/key_bindings.py,sha256=4oXdzcOw6f0SQa43bMS_mGdtXjsO_NWqgf7n7UiIRb4,10412
+klaude_code/ui/modes/repl/event_handler.py,sha256=pXjiLGilSzrsrr9lsk19NeiRGFjVq91Rtfp1PNLK36A,26026
+klaude_code/ui/modes/repl/input_prompt_toolkit.py,sha256=P8L7GhupoWTQNDkRXs8JpNiv5JRaw9VjXTG060h4DIw,8767
+klaude_code/ui/modes/repl/key_bindings.py,sha256=NKllb1W0LfJAZEqDjlW2aedBQ2PBEOOddoTiRNY1_mU,12121
 klaude_code/ui/modes/repl/renderer.py,sha256=7cum6SuKSuuBePDSyk4UvWs6q5dwgLA0NrJZ3eD9tHw,15902
 klaude_code/ui/renderers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 klaude_code/ui/renderers/assistant.py,sha256=7iu5zlHR7JGviHs2eA25Dsbd7ZkzCR2_0XzkqMPVxDI,862
 klaude_code/ui/renderers/bash_syntax.py,sha256=VcX_tuojOtS58s_Ff-Zmhw_6LBRn2wsvR5UBtEr_qQU,5923
 klaude_code/ui/renderers/common.py,sha256=l9V7yuiejowyw3FdZ2n3VJ2OO_K1rEUINmFz-mC2xlw,2648
-klaude_code/ui/renderers/developer.py,sha256=RrJsZphGdjuphIuTDnU1ivJ6tc-a3ndBvuyU17MQSQs,7776
+klaude_code/ui/renderers/developer.py,sha256=J6hBko8fiRxF67scI1NQ_Ztz3Y47VF3uxXblhIqUciE,8138
 klaude_code/ui/renderers/diffs.py,sha256=uLpgYTudH38wucozoUw4xbPWMC6uYTQTaDTHcg-0zvM,10418
-klaude_code/ui/renderers/errors.py,sha256=-geQA6neIkeQK_m0jaboSdVHmO61qd9620lo1a029bU,656
+klaude_code/ui/renderers/errors.py,sha256=MavmYOQ7lyjA_VpuUpDVFCuY9W7XrMVdLsg2lCOn4GY,655
 klaude_code/ui/renderers/mermaid_viewer.py,sha256=TIUFLtTqdG-iFD4Mgm8OdzU_9UO14niftTJ11f4makc,1691
 klaude_code/ui/renderers/metadata.py,sha256=jE_yxNIwsBMEiaiwd0b3czyKXkFbQZWQc5MYI-_2k5c,8280
 klaude_code/ui/renderers/sub_agent.py,sha256=g8QCFXTtFX_w8oTaGMYGuy6u5KqbFMlvzWofER0hGKk,5946
 klaude_code/ui/renderers/thinking.py,sha256=TbQxkjR6MuDXzASBK_rMaxxqvSdhfwDtVwXhOExuvlM,1946
-klaude_code/ui/renderers/tools.py,sha256=NWUwnNqXEWPrm6RnaIuQFpOrx0p5_6robwZhSayvp-Y,27892
+klaude_code/ui/renderers/tools.py,sha256=lebQHccj2tkJIjO-JB0TvCIixx-BKXHfD-egXSxBV7Y,27891
 klaude_code/ui/renderers/user_input.py,sha256=e2hZS7UUnzQuQ6UqzSKRDkFJMkKTLUoub1JclHMX40g,3941
 klaude_code/ui/rich/__init__.py,sha256=zEZjnHR3Fnv_sFMxwIMjoJfwDoC4GRGv3lHJzAGRq_o,236
 klaude_code/ui/rich/cjk_wrap.py,sha256=ncmifgTwF6q95iayHQyazGbntt7BRQb_Ed7aXc8JU6Y,7551
@@ -194,17 +194,18 @@ klaude_code/ui/rich/code_panel.py,sha256=ZKuJHh-kh-hIkBXSGLERLaDbJ7I9hvtvmYKocJn
 klaude_code/ui/rich/live.py,sha256=qiBLPSE4KW_Dpemy5MZ5BKhkFWEN2fjXBiQHmhJrPSM,2722
 klaude_code/ui/rich/markdown.py,sha256=ltcm4qVX6fsqUNkPWeOwX636FsQ6-gST6uLLcXAl9yA,15397
 klaude_code/ui/rich/quote.py,sha256=tZcxN73SfDBHF_qk0Jkh9gWBqPBn8VLp9RF36YRdKEM,1123
-klaude_code/ui/rich/searchable_text.py,sha256=DCVZgEFv7_ergAvT2v7XrfQAUXUzhmAwuVAchlIx8RY,2448
-klaude_code/ui/rich/status.py,sha256=QHg4oWmPSQH19H81vOFpImEqWyDtAbIXjuCGsuDjBPA,9278
+klaude_code/ui/rich/searchable_text.py,sha256=PUe6MotKxSBY4FlPeojVjVQgxCsx_jiQ41bCzLp8WvE,2271
+klaude_code/ui/rich/status.py,sha256=GKX_kMT42epQE_xIw2TvudprcMUNF8OpH9QvVjocdhk,10812
 klaude_code/ui/rich/theme.py,sha256=-jsQ5vB2kIM6hZD_YZZejS1OJQE4b48hJur-Hcnbhs4,14439
 klaude_code/ui/terminal/__init__.py,sha256=GIMnsEcIAGT_vBHvTlWEdyNmAEpruyscUA6M_j3GQZU,1412
 klaude_code/ui/terminal/color.py,sha256=jvVbuysf5pnI0uAjUVeyW2HwU58dutTg2msykbu2w4Y,7197
 klaude_code/ui/terminal/control.py,sha256=WhkqEWdtzUO4iWULp-iI9VazAWmzzW52qTQXk-4Dr4s,4922
 klaude_code/ui/terminal/notifier.py,sha256=wkRM66d98Oh6PujnN4bB7NiQxIYEHqQXverMKU43H5E,3187
 klaude_code/ui/terminal/progress_bar.py,sha256=MDnhPbqCnN4GDgLOlxxOEVZPDwVC_XL2NM5sl1MFNcQ,2133
+klaude_code/ui/terminal/selector.py,sha256=v0akaR4Jw5U_3fgK4INqf0R2nIhRZC-JqhECsF3z22I,9633
 klaude_code/ui/utils/__init__.py,sha256=YEsCLjbCPaPza-UXTPUMTJTrc9BmNBUP5CbFWlshyOQ,15
 klaude_code/ui/utils/common.py,sha256=tqHqwgLtAyP805kwRFyoAL4EgMutcNb3Y-GAXJ4IeuM,2263
-klaude_code-1.3.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-klaude_code-1.3.0.dist-info/entry_points.txt,sha256=kkXIXedaTOtjXPr2rVjRVVXZYlFUcBHELaqmyVlWUFA,92
-klaude_code-1.3.0.dist-info/METADATA,sha256=Eb3oOqTaMnmtF1ETnJda-XXad45O4_wvjeNTF8mviO4,9125
-klaude_code-1.3.0.dist-info/RECORD,,
+klaude_code-1.4.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+klaude_code-1.4.1.dist-info/entry_points.txt,sha256=kkXIXedaTOtjXPr2rVjRVVXZYlFUcBHELaqmyVlWUFA,92
+klaude_code-1.4.1.dist-info/METADATA,sha256=5cZHqchLcz-Jw9wBBudFwewS-S97SSJS3b8bJ3iEo4Y,9091
+klaude_code-1.4.1.dist-info/RECORD,,