klaude-code 1.5.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

klaude_code/cli/main.py

@@ -11,64 +11,11 @@ from klaude_code.cli.config_cmd import register_config_commands
 from klaude_code.cli.debug import DEBUG_FILTER_HELP, open_log_file_in_editor, resolve_debug_settings
 from klaude_code.cli.self_update import register_self_update_commands, version_option_callback
 from klaude_code.cli.session_cmd import register_session_commands
-from klaude_code.session import Session, build_session_select_options
+from klaude_code.command.resume_cmd import select_session_sync
+from klaude_code.session import Session
 from klaude_code.trace import DebugType, prepare_debug_log_file
 
 
-def select_session_interactive() -> str | None:
-    """Interactive session selection for CLI.
-
-    Returns:
-        Selected session ID, or None if no session selected or no sessions exist.
-    """
-    from klaude_code.trace import log
-
-    options = build_session_select_options()
-    if not options:
-        log("No sessions found for this project.")
-        return None
-
-    from prompt_toolkit.styles import Style
-
-    from klaude_code.ui.terminal.selector import SelectItem, select_one
-
-    items: list[SelectItem[str]] = []
-    for opt in options:
-        title = [
-            ("class:msg", f"{opt.first_user_message}\n"),
-            ("class:meta", f"   {opt.messages_count} · {opt.relative_time} · {opt.model_name} · {opt.session_id}\n\n"),
-        ]
-        items.append(
-            SelectItem(
-                title=title,
-                value=opt.session_id,
-                search_text=f"{opt.first_user_message} {opt.model_name} {opt.session_id}",
-            )
-        )
-
-    try:
-        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 KeyboardInterrupt:
-        return None
-
-
 def set_terminal_title(title: str) -> None:
     """Set terminal window title using ANSI escape sequence."""
     # Never write terminal control sequences when stdout is not a TTY (pipes/CI/redirects).
@@ -361,7 +308,7 @@ def main_callback(
         session_id: str | None = None
 
         if resume:
-            session_id = select_session_interactive()
+            session_id = select_session_sync()
             if session_id is None:
                 return
         # If user didn't pick, allow fallback to --continue

klaude_code/command/fork_session_cmd.py

@@ -1,5 +1,182 @@
+import asyncio
+import sys
+from dataclasses import dataclass
+from typing import Literal
+
+from prompt_toolkit.styles import Style
+
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
+from klaude_code.ui.terminal.selector import SelectItem, select_one
+
+FORK_SELECT_STYLE = Style(
+    [
+        ("msg", ""),
+        ("meta", "fg:ansibrightblack"),
+        ("separator", "fg:ansibrightblack"),
+        ("assistant", "fg:ansiblue"),
+        ("pointer", "bold fg:ansigreen"),
+        ("search_prefix", "fg:ansibrightblack"),
+        ("search_success", "noinherit fg:ansigreen"),
+        ("search_none", "noinherit fg:ansired"),
+        ("question", "bold"),
+        ("text", ""),
+    ]
+)
+
+
+@dataclass
+class ForkPoint:
+    """A fork point in conversation history."""
+
+    history_index: int | None  # None means fork entire conversation
+    user_message: str
+    tool_call_stats: dict[str, int]  # tool_name -> count
+    last_assistant_summary: str
+
+
+def _truncate(text: str, max_len: int = 60) -> str:
+    """Truncate text to max_len, adding ellipsis if needed."""
+    text = text.replace("\n", " ").strip()
+    if len(text) <= max_len:
+        return text
+    return text[: max_len - 3] + "..."
+
+
+def _build_fork_points(conversation_history: list[model.ConversationItem]) -> list[ForkPoint]:
+    """Build list of fork points from conversation history.
+
+    Fork points are:
+    - Each UserMessageItem position (for UI display, including first which would be empty session)
+    - The end of the conversation (fork entire conversation)
+    """
+    fork_points: list[ForkPoint] = []
+    user_indices: list[int] = []
+
+    for i, item in enumerate(conversation_history):
+        if isinstance(item, model.UserMessageItem):
+            user_indices.append(i)
+
+    # For each UserMessageItem, create a fork point at that position
+    for i, user_idx in enumerate(user_indices):
+        user_item = conversation_history[user_idx]
+        assert isinstance(user_item, model.UserMessageItem)
+
+        # Find the end of this "task" (next UserMessageItem or end of history)
+        next_user_idx = user_indices[i + 1] if i + 1 < len(user_indices) else len(conversation_history)
+
+        # Count tool calls by name and find last assistant message in this segment
+        tool_stats: dict[str, int] = {}
+        last_assistant_content = ""
+        for j in range(user_idx, next_user_idx):
+            item = conversation_history[j]
+            if isinstance(item, model.ToolCallItem):
+                tool_stats[item.name] = tool_stats.get(item.name, 0) + 1
+            elif isinstance(item, model.AssistantMessageItem) and item.content:
+                last_assistant_content = item.content
+
+        fork_points.append(
+            ForkPoint(
+                history_index=user_idx,
+                user_message=user_item.content or "(empty)",
+                tool_call_stats=tool_stats,
+                last_assistant_summary=_truncate(last_assistant_content) if last_assistant_content else "",
+            )
+        )
+
+    # Add the "fork entire conversation" option at the end
+    if user_indices:
+        fork_points.append(
+            ForkPoint(
+                history_index=None,  # None means fork entire conversation
+                user_message="",  # No specific message, this represents the end
+                tool_call_stats={},
+                last_assistant_summary="",
+            )
+        )
+
+    return fork_points
+
+
+def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | None]]:
+    """Build SelectItem list from fork points."""
+    items: list[SelectItem[int | None]] = []
+
+    for i, fp in enumerate(fork_points):
+        is_first = i == 0
+        is_last = i == len(fork_points) - 1
+
+        # Build the title
+        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"))
+        elif is_last:
+            title_parts.append(("class:separator", "----- fork from here (entire session) -----\n\n"))
+        else:
+            title_parts.append(("class:separator", "----- fork from here -----\n\n"))
+
+        if not is_last:
+            # Second line: user message
+            title_parts.append(("class:msg", f"user:   {_truncate(fp.user_message, 70)}\n"))
+
+            # Third line: tool call stats (if any)
+            if fp.tool_call_stats:
+                tool_parts = [f"{name} × {count}" for name, count in fp.tool_call_stats.items()]
+                title_parts.append(("class:meta", f"tools:  {', '.join(tool_parts)}\n"))
+
+            # Fourth line: last assistant message summary (if any)
+            if fp.last_assistant_summary:
+                title_parts.append(("class:assistant", f"ai:     {fp.last_assistant_summary}\n"))
+
+        # Empty line at the end
+        title_parts.append(("class:text", "\n"))
+
+        items.append(
+            SelectItem(
+                title=title_parts,
+                value=fp.history_index,
+                search_text=fp.user_message if not is_last else "fork entire conversation",
+            )
+        )
+
+    return items
+
+
+def _select_fork_point_sync(fork_points: list[ForkPoint]) -> int | None | Literal["cancelled"]:
+    """Interactive fork point selection (sync version for asyncio.to_thread).
+
+    Returns:
+        - int: history index to fork at (exclusive)
+        - None: fork entire conversation
+        - "cancelled": user cancelled selection
+    """
+    items = _build_select_items(fork_points)
+    if not items:
+        return None
+
+    # Default to the last option (fork entire conversation)
+    last_value = items[-1].value
+
+    # Non-interactive environments default to forking entire conversation
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        return last_value
+
+    try:
+        result = select_one(
+            message="Select fork point (messages before this point will be included):",
+            items=items,
+            pointer="→",
+            style=FORK_SELECT_STYLE,
+            initial_value=last_value,
+            highlight_pointed_item=False,
+        )
+        if result is None:
+            return "cancelled"
+        return result
+    except KeyboardInterrupt:
+        return "cancelled"
 
 
 class ForkSessionCommand(CommandABC):
@@ -13,6 +190,10 @@ class ForkSessionCommand(CommandABC):
     def summary(self) -> str:
         return "Fork the current session and show a resume-by-id command"
 
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
     async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
         del user_input  # unused
 
@@ -26,13 +207,50 @@ class ForkSessionCommand(CommandABC):
             )
             return CommandResult(events=[event], persist_user_input=False, persist_events=False)
 
-        new_session = agent.session.fork()
+        # Build fork points from conversation history
+        fork_points = _build_fork_points(agent.session.conversation_history)
+
+        if not fork_points:
+            # Only one user message, just fork entirely
+            new_session = agent.session.fork()
+            await new_session.wait_for_flush()
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Session forked successfully. New session id: {new_session.id}",
+                    command_output=model.CommandOutput(
+                        command_name=self.name,
+                        ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
+                    ),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # Interactive selection
+        selected = await asyncio.to_thread(_select_fork_point_sync, fork_points)
+
+        if selected == "cancelled":
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(fork cancelled)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # 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}"
+
         event = events.DeveloperMessageEvent(
             session_id=agent.session.id,
             item=model.DeveloperMessageItem(
-                content=f"Session forked successfully. New session id: {new_session.id}",
+                content=f"Session forked ({fork_description}). New session id: {new_session.id}",
                 command_output=model.CommandOutput(
                     command_name=self.name,
                     ui_extra=model.SessionIdUIExtra(session_id=new_session.id),

klaude_code/command/refresh_cmd.py

@@ -23,7 +23,7 @@ class RefreshTerminalCommand(CommandABC):
 
         os.system("cls" if os.name == "nt" else "clear")
 
-        result = CommandResult(
+        return CommandResult(
             events=[
                 events.WelcomeEvent(
                     work_dir=str(agent.session.work_dir),
@@ -35,7 +35,7 @@ class RefreshTerminalCommand(CommandABC):
                     updated_at=agent.session.updated_at,
                     is_load=False,
                 ),
-            ]
+            ],
+            persist_user_input=False,
+            persist_events=False,
         )
-
-        return result

klaude_code/command/resume_cmd.py

@@ -4,14 +4,14 @@ from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model, op
-from klaude_code.session.selector import build_session_select_options
+from klaude_code.session.selector import build_session_select_options, format_user_messages_display
 from klaude_code.trace import log
 from klaude_code.ui.terminal.selector import SelectItem, select_one
 
 SESSION_SELECT_STYLE = Style(
     [
-        ("msg", ""),
-        ("meta", "fg:ansibrightblack"),
+        ("msg", "fg:ansibrightblack"),
+        ("meta", ""),
         ("pointer", "bold fg:ansigreen"),
         ("highlighted", "fg:ansigreen"),
         ("search_prefix", "fg:ansibrightblack"),
@@ -23,7 +23,7 @@ SESSION_SELECT_STYLE = Style(
 )
 
 
-def _select_session_sync() -> str | None:
+def select_session_sync() -> str | None:
     """Interactive session selection (sync version for asyncio.to_thread)."""
     options = build_session_select_options()
     if not options:
@@ -31,16 +31,26 @@ def _select_session_sync() -> str | None:
         return None
 
     items: list[SelectItem[str]] = []
-    for opt in options:
-        title = [
-            ("class:msg", f"{opt.first_user_message}\n"),
-            ("class:meta", f"   {opt.messages_count} · {opt.relative_time} · {opt.model_name} · {opt.session_id}\n\n"),
-        ]
+    for idx, opt in enumerate(options, 1):
+        display_msgs = format_user_messages_display(opt.user_messages)
+        title: list[tuple[str, str]] = []
+        title.append(("fg:ansibrightblack", f"{idx:2}. "))
+        title.append(
+            ("class:meta", f"{opt.relative_time} · {opt.messages_count} · {opt.model_name} · {opt.session_id}\n")
+        )
+        for msg in display_msgs:
+            if msg == "⋮":
+                title.append(("class:msg", f"    {msg}\n"))
+            else:
+                title.append(("class:msg", f"    > {msg}\n"))
+        title.append(("", "\n"))
+
+        search_text = " ".join(opt.user_messages) + f" {opt.model_name} {opt.session_id}"
         items.append(
             SelectItem(
                 title=title,
                 value=opt.session_id,
-                search_text=f"{opt.first_user_message} {opt.model_name} {opt.session_id}",
+                search_text=search_text,
             )
         )
 
@@ -83,7 +93,7 @@ class ResumeCommand(CommandABC):
             )
             return CommandResult(events=[event], persist_user_input=False, persist_events=False)
 
-        selected_session_id = await asyncio.to_thread(_select_session_sync)
+        selected_session_id = await asyncio.to_thread(select_session_sync)
         if selected_session_id is None:
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,

klaude_code/llm/usage.py

@@ -81,7 +81,7 @@ class MetadataTracker:
             ) * 1000
 
             if self._last_token_time is not None and self._metadata_item.usage.output_tokens > 0:
-                time_duration = self._last_token_time - self._first_token_time
+                time_duration = self._last_token_time - self._request_start_time
                 if time_duration >= 0.15:
                     self._metadata_item.usage.throughput_tps = self._metadata_item.usage.output_tokens / time_duration
 

klaude_code/session/__init__.py

@@ -1,4 +1,4 @@
-from .selector import SessionSelectOption, build_session_select_options
+from .selector import SessionSelectOption, build_session_select_options, format_user_messages_display
 from .session import Session
 
-__all__ = ["Session", "SessionSelectOption", "build_session_select_options"]
+__all__ = ["Session", "SessionSelectOption", "build_session_select_options", "format_user_messages_display"]

klaude_code/session/selector.py

@@ -33,12 +33,39 @@ class SessionSelectOption:
     """Option data for session selection UI."""
 
     session_id: str
-    first_user_message: str
+    user_messages: list[str]
     messages_count: str
     relative_time: str
     model_name: str
 
 
+def _format_message(msg: str) -> str:
+    """Format a user message for display (strip and collapse newlines)."""
+    return msg.strip().replace("\n", " ")
+
+
+def format_user_messages_display(messages: list[str]) -> list[str]:
+    """Format user messages for display in session selection.
+
+    Shows up to 6 messages. If more than 6, shows first 3 and last 3 with ellipsis.
+    Each message is on its own line.
+
+    Args:
+        messages: List of user messages.
+
+    Returns:
+        List of formatted message lines for display.
+    """
+    if len(messages) <= 6:
+        return messages
+
+    # More than 6: show first 3, ellipsis, last 3
+    result = messages[:3]
+    result.append("⋮")
+    result.extend(messages[-3:])
+    return result
+
+
 def build_session_select_options() -> list[SessionSelectOption]:
     """Build session selection options data.
 
@@ -51,8 +78,9 @@ def build_session_select_options() -> list[SessionSelectOption]:
 
     options: list[SessionSelectOption] = []
     for s in sessions:
-        first_msg = s.first_user_message or "N/A"
-        first_msg = first_msg.strip().replace("\n", " ")
+        user_messages = [_format_message(m) for m in s.user_messages if m.strip()]
+        if not user_messages:
+            user_messages = ["N/A"]
 
         msg_count = "N/A" if s.messages_count == -1 else f"{s.messages_count} messages"
         model = s.model_name or "N/A"
@@ -60,7 +88,7 @@ def build_session_select_options() -> list[SessionSelectOption]:
         options.append(
             SessionSelectOption(
                 session_id=str(s.id),
-                first_user_message=first_msg,
+                user_messages=user_messages,
                 messages_count=msg_count,
                 relative_time=_relative_time(s.updated_at),
                 model_name=model,

klaude_code/session/session.py

@@ -197,11 +197,16 @@ class Session(BaseModel):
         )
         self._store.append_and_flush(session_id=self.id, items=items, meta=meta)
 
-    def fork(self, *, new_id: str | None = None) -> Session:
+    def fork(self, *, new_id: str | None = None, until_index: int | None = None) -> Session:
         """Create a new session as a fork of the current session.
 
         The forked session copies metadata and conversation history, but does not
         modify the current session.
+
+        Args:
+            new_id: Optional ID for the forked session.
+            until_index: If provided, only copy conversation history up to (but not including) this index.
+                         If None, copy all history.
         """
 
         forked = Session.create(id=new_id, work_dir=self.work_dir)
@@ -213,7 +218,8 @@ class Session(BaseModel):
         forked.file_tracker = {k: v.model_copy(deep=True) for k, v in self.file_tracker.items()}
         forked.todos = [todo.model_copy(deep=True) for todo in self.todos]
 
-        items = [it.model_copy(deep=True) for it in self.conversation_history]
+        history_to_copy = self.conversation_history[:until_index] if until_index is not None else self.conversation_history
+        items = [it.model_copy(deep=True) for it in history_to_copy]
         if items:
             forked.append_history(items)
 
@@ -338,7 +344,7 @@ class Session(BaseModel):
         updated_at: float
         work_dir: str
         path: str
-        first_user_message: str | None = None
+        user_messages: list[str] = []
         messages_count: int = -1
         model_name: str | None = None
 
@@ -346,10 +352,11 @@ class Session(BaseModel):
     def list_sessions(cls) -> list[SessionMetaBrief]:
         store = get_default_store()
 
-        def _get_first_user_message(session_id: str) -> str | None:
+        def _get_user_messages(session_id: str) -> list[str]:
             events_path = store.paths.events_file(session_id)
             if not events_path.exists():
-                return None
+                return []
+            messages: list[str] = []
             try:
                 for line in events_path.read_text(encoding="utf-8").splitlines():
                     obj_raw = json.loads(line)
@@ -360,15 +367,14 @@ class Session(BaseModel):
                         continue
                     data_raw = obj.get("data")
                     if not isinstance(data_raw, dict):
-                        return None
+                        continue
                     data = cast(dict[str, Any], data_raw)
                     content = data.get("content")
                     if isinstance(content, str):
-                        return content
-                    return None
+                        messages.append(content)
             except (OSError, json.JSONDecodeError):
-                return None
-            return None
+                pass
+            return messages
 
         items: list[Session.SessionMetaBrief] = []
         for meta_path in store.iter_meta_files():
@@ -382,7 +388,7 @@ class Session(BaseModel):
             created = float(data.get("created_at", meta_path.stat().st_mtime))
             updated = float(data.get("updated_at", meta_path.stat().st_mtime))
             work_dir = str(data.get("work_dir", ""))
-            first_user_message = _get_first_user_message(sid)
+            user_messages = _get_user_messages(sid)
             messages_count = int(data.get("messages_count", -1))
             model_name = data.get("model_name") if isinstance(data.get("model_name"), str) else None
 
@@ -393,7 +399,7 @@ class Session(BaseModel):
                     updated_at=updated,
                     work_dir=work_dir,
                     path=str(meta_path),
-                    first_user_message=first_user_message,
+                    user_messages=user_messages,
                     messages_count=messages_count,
                     model_name=model_name,
                 )

klaude_code/ui/modes/repl/event_handler.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-from rich.cells import cell_len
 from rich.rule import Rule
 from rich.text import Text
 
@@ -265,11 +264,27 @@ class SpinnerStatusState:
 
         return result
 
-    def get_context_text(self) -> Text | None:
-        """Get context usage text for right-aligned display."""
-        if self._context_percent is None:
+    def get_right_text(self) -> r_status.DynamicText | None:
+        """Get right-aligned status text (elapsed time and optional context %)."""
+
+        elapsed_text = r_status.current_elapsed_text()
+        has_context = self._context_percent is not None
+
+        if elapsed_text is None and not has_context:
             return None
-        return Text(f"{self._context_percent:.1f}%", style=ThemeKey.METADATA_DIM)
+
+        def _render() -> Text:
+            parts: list[str] = []
+            if self._context_percent is not None:
+                parts.append(f"{self._context_percent:.1f}%")
+            current_elapsed = r_status.current_elapsed_text()
+            if current_elapsed is not None:
+                if parts:
+                    parts.append(" · ")
+                parts.append(current_elapsed)
+            return Text("".join(parts), style=ThemeKey.METADATA_DIM)
+
+        return r_status.DynamicText(_render)
 
 
 class DisplayEventHandler:
@@ -550,11 +565,10 @@ class DisplayEventHandler:
     def _update_spinner(self) -> None:
         """Update spinner text from current status state."""
         status_text = self.spinner_status.get_status()
-        context_text = self.spinner_status.get_context_text()
-        status_text = self._truncate_spinner_status_text(status_text, right_text=context_text)
+        right_text = self.spinner_status.get_right_text()
         self.renderer.spinner_update(
             status_text,
-            context_text,
+            right_text,
         )
 
     async def _flush_assistant_buffer(self, state: StreamState) -> None:
@@ -612,27 +626,3 @@ class DisplayEventHandler:
                 if len(todo.content) > 0:
                     status_text = todo.content
         return status_text.replace("\n", " ").strip()
-
-    def _truncate_spinner_status_text(self, status_text: Text, *, right_text: Text | None) -> Text:
-        """Truncate spinner status to a single line based on terminal width.
-
-        Rich wraps based on terminal cell width (CJK chars count as 2). Use
-        cell-aware truncation to prevent the status from wrapping into two lines.
-        """
-
-        terminal_width = self.renderer.console.size.width
-
-        # BreathingSpinner renders as a 2-column Table.grid(padding=1):
-        # 1 cell for glyph + 1 cell of padding between columns (collapsed).
-        spinner_prefix_cells = 2
-
-        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
-        # rich.text.Text.truncate behaves unexpectedly for 0; clamp to at least 1.
-        max_main_cells = max(1, max_main_cells)
-
-        truncated = status_text.copy()
-        truncated.truncate(max_main_cells, overflow="ellipsis", pad=False)
-        return truncated

klaude_code/ui/modes/repl/renderer.py

@@ -283,7 +283,7 @@ class REPLRenderer:
         self._spinner_visible = False
         self._refresh_bottom_live()
 
-    def spinner_update(self, status_text: str | Text, right_text: Text | None = None) -> None:
+    def spinner_update(self, status_text: str | Text, right_text: RenderableType | None = None) -> None:
         """Update the spinner status text with optional right-aligned text."""
         self._status_text = ShimmerStatusText(status_text, right_text)
         self._status_spinner.update(text=SingleLine(self._status_text), style=ThemeKey.STATUS_SPINNER)

klaude_code/ui/renderers/developer.py

@@ -161,10 +161,10 @@ def _format_cost(cost: float | None, currency: str = "USD") -> str:
 def _render_fork_session_output(command_output: model.CommandOutput) -> RenderableType:
     """Render fork session output with usage instructions."""
     if not isinstance(command_output.ui_extra, model.SessionIdUIExtra):
-        return Text("(no session id)", style=ThemeKey.METADATA)
+        return Padding.indent(Text("(no session id)", style=ThemeKey.METADATA), level=2)
 
-    session_id = command_output.ui_extra.session_id
     grid = Table.grid(padding=(0, 1))
+    session_id = command_output.ui_extra.session_id
     grid.add_column(style=ThemeKey.METADATA, overflow="fold")
 
     grid.add_row(Text("Session forked. To continue in a new conversation:", style=ThemeKey.METADATA))

klaude_code/ui/renderers/metadata.py

@@ -6,6 +6,7 @@ from rich.padding import Padding
 from rich.panel import Panel
 from rich.text import Text
 
+from klaude_code import const
 from klaude_code.protocol import events, model
 from klaude_code.trace import is_debug_enabled
 from klaude_code.ui.renderers.common import create_grid
@@ -95,10 +96,17 @@ def _render_task_metadata_block(
         # Context (only for main agent)
         if show_context_and_time and metadata.usage.context_usage_percent is not None:
             context_size = format_number(metadata.usage.context_size or 0)
+            # Calculate effective limit (same as Usage.context_usage_percent)
+            effective_limit = (metadata.usage.context_limit or 0) - (
+                metadata.usage.max_tokens or const.DEFAULT_MAX_TOKENS
+            )
+            effective_limit_str = format_number(effective_limit) if effective_limit > 0 else "?"
             parts.append(
                 Text.assemble(
                     ("context ", ThemeKey.METADATA_DIM),
                     (context_size, ThemeKey.METADATA),
+                    ("/", ThemeKey.METADATA_DIM),
+                    (effective_limit_str, ThemeKey.METADATA),
                     (f" ({metadata.usage.context_usage_percent:.1f}%)", ThemeKey.METADATA_DIM),
                 )
             )

klaude_code/ui/rich/markdown.py

@@ -254,18 +254,36 @@ class MarkdownStream:
         live suffix separately may introduce an extra blank line that wouldn't
         appear when rendering the full document.
 
-        This function removes leading blank lines from the live ANSI when the
-        stable ANSI already ends with a blank line.
+        This function removes *overlapping* blank lines from the live ANSI when
+        the stable ANSI already ends with one or more blank lines.
+
+        Important: don't remove *all* leading blank lines from the live suffix.
+        In some incomplete-block cases, the live render may begin with multiple
+        blank lines while the full-document render would keep one of them.
         """
 
         stable_lines = stable_ansi.splitlines(keepends=True)
-        stable_ends_blank = bool(stable_lines) and not stable_lines[-1].strip()
-        if not stable_ends_blank:
+        if not stable_lines:
+            return live_ansi
+
+        stable_trailing_blank = 0
+        for line in reversed(stable_lines):
+            if line.strip():
+                break
+            stable_trailing_blank += 1
+        if stable_trailing_blank <= 0:
             return live_ansi
 
         live_lines = live_ansi.splitlines(keepends=True)
-        while live_lines and not live_lines[0].strip():
-            live_lines.pop(0)
+        live_leading_blank = 0
+        for line in live_lines:
+            if line.strip():
+                break
+            live_leading_blank += 1
+
+        drop = min(stable_trailing_blank, live_leading_blank)
+        if drop > 0:
+            live_lines = live_lines[drop:]
         return "".join(live_lines)
 
     def _append_nonfinal_sentinel(self, stable_source: str) -> str:
@@ -400,9 +418,23 @@ class MarkdownStream:
             apply_mark_live = self._stable_source_line_count == 0
             live_lines = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_live)
 
-            if self._stable_rendered_lines and not self._stable_rendered_lines[-1].strip():
-                while live_lines and not live_lines[0].strip():
-                    live_lines.pop(0)
+            if self._stable_rendered_lines:
+                stable_trailing_blank = 0
+                for line in reversed(self._stable_rendered_lines):
+                    if line.strip():
+                        break
+                    stable_trailing_blank += 1
+
+                if stable_trailing_blank > 0:
+                    live_leading_blank = 0
+                    for line in live_lines:
+                        if line.strip():
+                            break
+                        live_leading_blank += 1
+
+                    drop = min(stable_trailing_blank, live_leading_blank)
+                    if drop > 0:
+                        live_lines = live_lines[drop:]
 
             live_text = Text.from_ansi("".join(live_lines))
             self._live_sink(live_text)

klaude_code/ui/rich/status.py

@@ -4,10 +4,13 @@ import contextlib
 import math
 import random
 import time
+from collections.abc import Callable
 
 import rich.status as rich_status
+from rich.cells import cell_len
 from rich.color import Color
 from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
+from rich.measure import Measurement
 from rich.spinner import Spinner as RichSpinner
 from rich.style import Style
 from rich.table import Table
@@ -80,20 +83,63 @@ def _format_elapsed_compact(seconds: float) -> str:
 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.
+    The hint is the constant suffix shown after the main status text.
+
+    The elapsed task time is rendered on the right side of the status line
+    (near context usage), not inside the hint.
     """
 
+    # Keep the signature stable; min_time_width is intentionally ignored.
+    _ = min_time_width
+    return const.STATUS_HINT_TEXT
+
+
+def current_elapsed_text(*, min_time_width: int = 0) -> str | None:
+    """Return the current task elapsed time text (e.g. "11s", "1m02s")."""
+
     elapsed = _task_elapsed_seconds()
     if elapsed is None:
-        return const.STATUS_HINT_TEXT
+        return None
     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})"
+    return time_text
+
+
+class DynamicText:
+    """Renderable that materializes a Text instance at render time.
+
+    This is useful for status line elements that should refresh without
+    requiring explicit spinner_update calls (e.g. elapsed time).
+    """
+
+    def __init__(
+        self,
+        factory: Callable[[], Text],
+        *,
+        min_width_cells: int = 0,
+    ) -> None:
+        self._factory = factory
+        self.min_width_cells = min_width_cells
+
+    @property
+    def plain(self) -> str:
+        return self._factory().plain
+
+    def __rich_measure__(self, console: Console, options: ConsoleOptions) -> Measurement:
+        # Ensure Table/grid layout allocates a stable width for this renderable.
+        text = self._factory()
+        measured = Measurement.get(console, options, text)
+        min_width = max(measured.minimum, self.min_width_cells)
+        max_width = max(measured.maximum, self.min_width_cells)
+
+        limit = getattr(options, "max_width", options.size.width)
+        max_width = min(max_width, limit)
+        min_width = min(min_width, max_width)
+        return Measurement(min_width, max_width)
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        yield self._factory()
 
 
 def _shimmer_profile(main_text: str) -> list[tuple[str, float]]:
@@ -220,7 +266,7 @@ class ShimmerStatusText:
     def __init__(
         self,
         main_text: str | Text,
-        right_text: Text | None = None,
+        right_text: RenderableType | None = None,
         main_style: ThemeKey = ThemeKey.STATUS_TEXT,
     ) -> None:
         if isinstance(main_text, Text):
@@ -234,34 +280,49 @@ class ShimmerStatusText:
         self._right_text = right_text
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
-        left_text = self._render_left_text(console)
+        left_text = _StatusLeftText(main=self._main_text, hint_style=self._hint_style)
 
         if self._right_text is None:
             yield left_text
             return
 
-        # Use Table.grid to create left-right aligned layout
-        table = Table.grid(expand=True)
+        # Use Table.grid to create left-right aligned layout with a stable gap.
+        table = Table.grid(expand=True, padding=(0, 1, 0, 0), collapse_padding=True, pad_edge=False)
         table.add_column(justify="left", ratio=1)
         table.add_column(justify="right")
         table.add_row(left_text, self._right_text)
         yield table
 
-    def _render_left_text(self, console: Console) -> Text:
-        """Render the left part with shimmer effect on main text only."""
-        result = Text()
-        hint_style = console.get_style(str(self._hint_style))
 
-        # Apply shimmer only to main text
-        for index, (ch, intensity) in enumerate(_shimmer_profile(self._main_text.plain)):
-            base_style = self._main_text.get_style_at_offset(console, index)
+class _StatusLeftText:
+    def __init__(self, *, main: Text, hint_style: ThemeKey) -> None:
+        self._main = main
+        self._hint_style = hint_style
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        max_width = getattr(options, "max_width", options.size.width)
+
+        # Keep the hint visually attached to the status text, while truncating only
+        # the main status segment when space is tight.
+        hint_text = Text(current_hint_text().strip("\n"), style=console.get_style(str(self._hint_style)))
+        hint_cells = cell_len(hint_text.plain)
+
+        main_text = Text()
+        for index, (ch, intensity) in enumerate(_shimmer_profile(self._main.plain)):
+            base_style = self._main.get_style_at_offset(console, index)
             style = _shimmer_style(console, base_style, intensity)
-            result.append(ch, style=style)
+            main_text.append(ch, style=style)
 
-        # Append hint text without shimmer
-        result.append(current_hint_text().strip("\n"), style=hint_style)
+        # If the hint itself can't fit, fall back to truncating the combined text.
+        if max_width <= hint_cells:
+            combined = Text.assemble(main_text, hint_text)
+            combined.truncate(max(1, max_width), overflow="ellipsis", pad=False)
+            yield combined
+            return
 
-        return result
+        main_budget = max_width - hint_cells
+        main_text.truncate(max(1, main_budget), overflow="ellipsis", pad=False)
+        yield Text.assemble(main_text, hint_text)
 
 
 def spinner_name() -> str:

klaude_code/ui/terminal/selector.py

@@ -98,6 +98,53 @@ def _restyle_title(title: list[tuple[str, str]], cls: str) -> list[tuple[str, st
     return restyled
 
 
+def _indent_multiline_tokens(
+    tokens: list[tuple[str, str]],
+    indent: str,
+    *,
+    indent_style: str = "class:text",
+) -> list[tuple[str, str]]:
+    """Indent continuation lines inside formatted tokens.
+
+    This is needed when an item's title contains embedded newlines. The selector
+    prefixes each *item* with the pointer padding, but continuation lines inside
+    a single item would otherwise start at column 0.
+    """
+    if not tokens or all("\n" not in text for _style, text in tokens):
+        return tokens
+
+    def _has_non_newline_text(s: str) -> bool:
+        return bool(s.replace("\n", ""))
+
+    has_text_after_token: list[bool] = [False] * len(tokens)
+    remaining = False
+    for i in range(len(tokens) - 1, -1, -1):
+        has_text_after_token[i] = remaining
+        remaining = remaining or _has_non_newline_text(tokens[i][1])
+
+    out: list[tuple[str, str]] = []
+    for token_index, (style, text) in enumerate(tokens):
+        if "\n" not in text:
+            out.append((style, text))
+            continue
+
+        parts = text.split("\n")
+        for part_index, part in enumerate(parts):
+            if part:
+                out.append((style, part))
+
+            # If this was a newline, re-add it.
+            if part_index < len(parts) - 1:
+                out.append((style, "\n"))
+
+                # Only indent when there is more text remaining within this item.
+                has_text_later_in_token = any(p for p in parts[part_index + 1 :])
+                if has_text_later_in_token or has_text_after_token[token_index]:
+                    out.append((indent_style, indent))
+
+    return out
+
+
 def _filter_items[T](
     items: list[SelectItem[T]],
     filter_text: str,
@@ -120,6 +167,8 @@ def _build_choices_tokens[T](
     visible_indices: list[int],
     pointed_at: int,
     pointer: str,
+    *,
+    highlight_pointed_item: bool = True,
 ) -> list[tuple[str, str]]:
     """Build formatted tokens for the choice list."""
     if not visible_indices:
@@ -137,7 +186,12 @@ def _build_choices_tokens[T](
         else:
             tokens.append(("class:text", pointer_pad))
 
-        title_tokens = _restyle_title(items[idx].title, "class:highlighted") if is_pointed else items[idx].title
+        if is_pointed and highlight_pointed_item:
+            title_tokens = _restyle_title(items[idx].title, "class:highlighted")
+        else:
+            title_tokens = items[idx].title
+
+        title_tokens = _indent_multiline_tokens(title_tokens, pointer_pad)
         tokens.extend(title_tokens)
 
     return tokens
@@ -226,6 +280,7 @@ def select_one[T](
     use_search_filter: bool = True,
     initial_value: T | None = None,
     search_placeholder: str = "type to search",
+    highlight_pointed_item: bool = True,
 ) -> T | None:
     """Terminal single-choice selector based on prompt_toolkit."""
     if not items:
@@ -250,7 +305,13 @@ def select_one[T](
         indices, _ = _filter_items(items, get_filter_text())
         if indices:
             pointed_at %= len(indices)
-        return _build_choices_tokens(items, indices, pointed_at, pointer)
+        return _build_choices_tokens(
+            items,
+            indices,
+            pointed_at,
+            pointer,
+            highlight_pointed_item=highlight_pointed_item,
+        )
 
     def on_search_changed(_buf: Buffer) -> None:
         nonlocal pointed_at
@@ -376,6 +437,7 @@ class SelectOverlay[T]:
         use_search_filter: bool = True,
         search_placeholder: str = "type to search",
         list_height: int = 8,
+        highlight_pointed_item: bool = True,
         on_select: Callable[[T], Coroutine[Any, Any, None] | None] | None = None,
         on_cancel: Callable[[], Coroutine[Any, Any, None] | None] | None = None,
     ) -> None:
@@ -383,6 +445,7 @@ class SelectOverlay[T]:
         self._use_search_filter = use_search_filter
         self._search_placeholder = search_placeholder
         self._list_height = max(1, list_height)
+        self._highlight_pointed_item = highlight_pointed_item
         self._on_select = on_select
         self._on_cancel = on_cancel
 
@@ -482,7 +545,13 @@ class SelectOverlay[T]:
             indices, _ = self._get_visible_indices()
             if indices:
                 self._pointed_at %= len(indices)
-            return _build_choices_tokens(self._items, indices, self._pointed_at, self._pointer)
+            return _build_choices_tokens(
+                self._items,
+                indices,
+                self._pointed_at,
+                self._pointer,
+                highlight_pointed_item=self._highlight_pointed_item,
+            )
 
         header_window = Window(
             FormattedTextControl(get_header_tokens),

{klaude_code-1.5.0.dist-info → klaude_code-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.5.0
+Version: 1.6.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0

{klaude_code-1.5.0.dist-info → klaude_code-1.6.0.dist-info}/RECORD

@@ -10,7 +10,7 @@ klaude_code/cli/auth_cmd.py,sha256=UWMHjn9xZp2o8OZc-x8y9MnkZgRWOkFXk05iKJYcySE,2
 klaude_code/cli/config_cmd.py,sha256=hlvslLNgdRHkokq1Pnam0XOdR3jqO3K0vNLqtWnPa6Q,3261
 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=vTnKdSDJBeXy8fxxyrzNDIaa-2XxH0Zi9BvO1qIOIbM,14935
+klaude_code/cli/main.py,sha256=uNZl0RjeLRITbfHerma4_kq2f0hF166dFZqAHLBu580,13236
 klaude_code/cli/runtime.py,sha256=6CtsQa8UcC9ppnNm2AvsF3yxgncyEYwpIIX0bb-3NN0,19826
 klaude_code/cli/self_update.py,sha256=iGuj0i869Zi0M70W52-VVLxZp90ISr30fQpZkHGMK2o,8059
 klaude_code/cli/session_cmd.py,sha256=q2YarlV6KARkFnbm_36ZUvBh8Noj8B7TlMg1RIlt1GE,3154
@@ -20,17 +20,17 @@ klaude_code/command/command_abc.py,sha256=wZl_azY6Dpd4OvjtkSEPI3ilXaygLIVkO7NCgN
 klaude_code/command/debug_cmd.py,sha256=9sBIAwHz28QoI-tHsU3ksQlDObF1ilIbtAAEAVMR0v0,2734
 klaude_code/command/export_cmd.py,sha256=Cs7YXWtos-ZfN9OEppIl8Xrb017kDG7R6hGiilqt2bM,1623
 klaude_code/command/export_online_cmd.py,sha256=RYYLnkLtg6edsgysmhsfTw16ncFRIT6PqeTdWhWXLHE,6094
-klaude_code/command/fork_session_cmd.py,sha256=T3o0mOVcqL2Ts39Ijl4t2Sl0GYbvh8zyd9z21M-AThU,1682
+klaude_code/command/fork_session_cmd.py,sha256=ocVg1YZw99RWmoCu67L6zOyIzz49CgTQRA36NFjgt-k,9672
 klaude_code/command/help_cmd.py,sha256=wtmOoi4DVaMJPCXLlNKJ4s-kNycNKuYk0MZkZijXLcQ,1666
 klaude_code/command/model_cmd.py,sha256=h3jUi9YOhT9rN87yfCxxU-yN3UiUzwI7Xf2UsRjjP5I,2956
 klaude_code/command/model_select.py,sha256=_TquYw8zDQHkEaRCqOCIcD2XWt8Jg-3WfGhHFSsjFw0,3189
 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
-klaude_code/command/refresh_cmd.py,sha256=575eJ5IsOc1e_7CulMxvTu5GQ6BaXTG1k8IsAqzrwdQ,1244
+klaude_code/command/refresh_cmd.py,sha256=Gd5-Vg8VRMOAMgXOzR2Y8wtVQudL0TWEdkut_fyQjQs,1292
 klaude_code/command/registry.py,sha256=IeOGJ_TMWb_EE5c2JnWYR6XdDfwYfQDFAikI4u_5tXw,6904
 klaude_code/command/release_notes_cmd.py,sha256=FIrBRfKTlXEp8mBh15buNjgOrl_GMX7FeeMWxYYBn1o,2674
-klaude_code/command/resume_cmd.py,sha256=dOvq4OoaNU2MCXfJW9eRYZLZnGkTMef5H8LvhX60yqI,3510
+klaude_code/command/resume_cmd.py,sha256=YiIj4jbabf8QGTZoIkTjGWmrBof24r98zwNRd-NuROU,3945
 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=NPejWmx6HDxoWzAJVLEENCr3Wi6sQSbT8A8LRh1-2Nk,3059
@@ -126,7 +126,7 @@ klaude_code/llm/registry.py,sha256=grgHetTd-lSxTXiY689QW_Zd6voaid7qBqSnulpg_fE,1
 klaude_code/llm/responses/__init__.py,sha256=WsiyvnNiIytaYcaAqNiB8GI-5zcpjjeODPbMlteeFjA,67
 klaude_code/llm/responses/client.py,sha256=XEsVehevQJ0WFbEVxIkI-su7VwIcaeq0P9eSrIRcGug,10184
 klaude_code/llm/responses/input.py,sha256=qr61LmQJdcb_f-ofrAz06WpK_k4PEcI36XsyuZAXbKk,6805
-klaude_code/llm/usage.py,sha256=cq6yZNSKBhRVVjFqBYJQrK3mw9ZSLXaTpbDeal-BjBQ,4205
+klaude_code/llm/usage.py,sha256=ohQ6EBsWXZj6B4aJ4lDPqfhXRyd0LUAM1nXEJ_elD7A,4207
 klaude_code/protocol/__init__.py,sha256=aGUgzhYqvhuT3Mk2vj7lrHGriH4h9TSbqV1RsRFAZjQ,194
 klaude_code/protocol/commands.py,sha256=4tFt98CD_KvS9C-XEaHLN-S-QFsbDxQb_kGKnPkQlrk,958
 klaude_code/protocol/events.py,sha256=KUMf1rLNdHQO9cZiQ9Pa1VsKkP1PTMbUkp18bu_jGy8,3935
@@ -140,11 +140,11 @@ klaude_code/protocol/sub_agent/oracle.py,sha256=0cbuutKQcvwaM--Q15mbkCdbpZMF4Yjx
 klaude_code/protocol/sub_agent/task.py,sha256=3RYXTfK0vqSevv0MG3DYUpExrCS2F3Cvszl_Zz9d8-g,3620
 klaude_code/protocol/sub_agent/web.py,sha256=Z5vUM367kz8CIexN6UVPG4XxzVOaaRek-Ga64NvcZdk,3043
 klaude_code/protocol/tools.py,sha256=ejhMCBBMz1ODbPEiynhzjB-aLbIRKL-wipPFv-nEz4g,373
-klaude_code/session/__init__.py,sha256=-iKgJA4Pl0Yg6tqStEpGh8eT3SzWl2iRg-QfefuR4Ow,179
+klaude_code/session/__init__.py,sha256=4sw81uQvEd3YUOOjamKk1KqGmxeb4Ic9T1Tee5zztyU,241
 klaude_code/session/codec.py,sha256=ummbqT7t6uHHXtaS9lOkyhi1h0YpMk7SNSms8DyGAHU,2015
 klaude_code/session/export.py,sha256=dj-IRUNtXL8uONDj9bsEXcEHKyeHY7lIcXv80yP88h4,31022
-klaude_code/session/selector.py,sha256=xxu28og7Qvk2gBb3O4zC1o_lP8sVmMlzd511-kZtfeM,1986
-klaude_code/session/session.py,sha256=otWpPnCk5LGS5IW_zTdeXBtLdxbBlEK2jH5FnrOIpF4,16969
+klaude_code/session/selector.py,sha256=FpKpGs06fM-LdV-yVUqEY-FJsFn2OtGK-0paXjsZVTg,2770
+klaude_code/session/session.py,sha256=CUbIBpPgl_m2lr3h5jZNktJG0S5eYGZkL37seWdZ7uw,17318
 klaude_code/session/store.py,sha256=-e-lInCB3N1nFLlet7bipkmPk1PXmGthuMxv5z3hg5o,6953
 klaude_code/session/templates/export_session.html,sha256=bA27AkcC7DQRoWmcMBeaR8WOx1z76hezEDf0aYH-0HQ,119780
 klaude_code/session/templates/mermaid_viewer.html,sha256=lOkETxlctX1C1WJtS1wFw6KhNQmemxwJZFpXDSjlMOk,27842
@@ -173,19 +173,19 @@ 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=zH5zslovTKJwH1Gu8ZufvMDGkSd342F6fHE1hjlxHgM,31849
 klaude_code/ui/modes/repl/display.py,sha256=06wawOHWO2ItEA9EIEh97p3GDID7TJhAtpaA03nPQXs,2335
-klaude_code/ui/modes/repl/event_handler.py,sha256=wDMkG4MpV0SEGmQaX-rOCJyomEdy0JYIDK0VB7R_RXo,26127
+klaude_code/ui/modes/repl/event_handler.py,sha256=O8yDr4xNMAqgXEiT90KWBoQX-2pIPjVf591QJ0ftjIo,25482
 klaude_code/ui/modes/repl/input_prompt_toolkit.py,sha256=40PfnhMCeOHEkb8MQFpyA4qIkWhYmhjosb3NAeFxyqM,28434
 klaude_code/ui/modes/repl/key_bindings.py,sha256=tZV0ILMWpHCPcVFpf9bnbTSXgnnqsW0-6cCMMVTRciA,13023
-klaude_code/ui/modes/repl/renderer.py,sha256=7cum6SuKSuuBePDSyk4UvWs6q5dwgLA0NrJZ3eD9tHw,15902
+klaude_code/ui/modes/repl/renderer.py,sha256=kdJKRGMGEQFskHeibkI-heoFZP6ucHOK_x7brXPhNCI,15912
 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=J6hBko8fiRxF67scI1NQ_Ztz3Y47VF3uxXblhIqUciE,8138
+klaude_code/ui/renderers/developer.py,sha256=JB8NZ6blur8U6Gn4uUMg6dOTmaMNvTcxxaOk3P9toHo,8163
 klaude_code/ui/renderers/diffs.py,sha256=uLpgYTudH38wucozoUw4xbPWMC6uYTQTaDTHcg-0zvM,10418
 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=hB0l9gkt9JY_4c_JBcUB3BxHTl0sz4_zmggZesU0C3o,8105
+klaude_code/ui/renderers/metadata.py,sha256=EWxh5UTSZG_vRVf6taKI_E1YkR_56U1Gs9soDuZcpq4,8576
 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=lebQHccj2tkJIjO-JB0TvCIixx-BKXHfD-egXSxBV7Y,27891
@@ -194,20 +194,20 @@ klaude_code/ui/rich/__init__.py,sha256=zEZjnHR3Fnv_sFMxwIMjoJfwDoC4GRGv3lHJzAGRq
 klaude_code/ui/rich/cjk_wrap.py,sha256=ncmifgTwF6q95iayHQyazGbntt7BRQb_Ed7aXc8JU6Y,7551
 klaude_code/ui/rich/code_panel.py,sha256=ZKuJHh-kh-hIkBXSGLERLaDbJ7I9hvtvmYKocJn39_w,4744
 klaude_code/ui/rich/live.py,sha256=qiBLPSE4KW_Dpemy5MZ5BKhkFWEN2fjXBiQHmhJrPSM,2722
-klaude_code/ui/rich/markdown.py,sha256=ltcm4qVX6fsqUNkPWeOwX636FsQ6-gST6uLLcXAl9yA,15397
+klaude_code/ui/rich/markdown.py,sha256=0tU4i1QTsyfjTf8sL-s-Ui-MMXyq-U4f2n465qJc_Xs,16486
 klaude_code/ui/rich/quote.py,sha256=tZcxN73SfDBHF_qk0Jkh9gWBqPBn8VLp9RF36YRdKEM,1123
 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/status.py,sha256=M_pPNbZUYJ7uaxSGoSaNGrzPhHDZfcV2gjUeu8XmYNg,13192
 klaude_code/ui/rich/theme.py,sha256=5R2TpedF21iQHgF4sVwlWcCBjNJ-sOcneHScDBH3hHI,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=Mi7UlpAYgNj4mhsGLSdQxa2tQNfE3c6jCcT3U_v_vQ4,4577
 klaude_code/ui/terminal/progress_bar.py,sha256=MDnhPbqCnN4GDgLOlxxOEVZPDwVC_XL2NM5sl1MFNcQ,2133
-klaude_code/ui/terminal/selector.py,sha256=8fIgquPkLwKicBXhqbSpNrXphPNDOhH9ku0HCgIzPXc,19886
+klaude_code/ui/terminal/selector.py,sha256=NblhWxUp0AW2OyepG4DHNy4yKE947Oi0OiqlafvBCEE,22144
 klaude_code/ui/utils/__init__.py,sha256=YEsCLjbCPaPza-UXTPUMTJTrc9BmNBUP5CbFWlshyOQ,15
 klaude_code/ui/utils/common.py,sha256=tqHqwgLtAyP805kwRFyoAL4EgMutcNb3Y-GAXJ4IeuM,2263
-klaude_code-1.5.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-klaude_code-1.5.0.dist-info/entry_points.txt,sha256=kkXIXedaTOtjXPr2rVjRVVXZYlFUcBHELaqmyVlWUFA,92
-klaude_code-1.5.0.dist-info/METADATA,sha256=4r92SCibfnKrzXtU40YNrRIQPn7Tzdq6tBh4yOhQbUM,9091
-klaude_code-1.5.0.dist-info/RECORD,,
+klaude_code-1.6.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+klaude_code-1.6.0.dist-info/entry_points.txt,sha256=kkXIXedaTOtjXPr2rVjRVVXZYlFUcBHELaqmyVlWUFA,92
+klaude_code-1.6.0.dist-info/METADATA,sha256=h5IGANYxmMyc3H-4lRuaTKpumksBz0NEnJBAwbSZMuU,9091
+klaude_code-1.6.0.dist-info/RECORD,,