klaude-code 1.2.27__py3-none-any.whl → 1.2.28__py3-none-any.whl

klaude_code/cli/debug.py

@@ -63,7 +63,15 @@ def open_log_file_in_editor(path: Path) -> None:
             editor = "xdg-open"
 
     try:
-        subprocess.Popen([editor, str(path)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        # Detach stdin to prevent the editor from interfering with terminal input state.
+        # Without this, the spawned process inherits the parent's TTY and can disrupt
+        # prompt_toolkit's keyboard handling (e.g., history navigation with up/down keys).
+        subprocess.Popen(
+            [editor, str(path)],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
     except FileNotFoundError:
         log((f"Error: Editor '{editor}' not found", "red"))
     except Exception as exc:  # pragma: no cover - best effort

klaude_code/cli/main.py

@@ -16,6 +16,10 @@ from klaude_code.trace import DebugType, prepare_debug_log_file
 
 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).
+    # This avoids corrupting machine-readable output (e.g., JSON streaming) and log captures.
+    if not sys.stdout.isatty():
+        return
     sys.stdout.write(f"\033]0;{title}\007")
     sys.stdout.flush()
 
@@ -242,9 +246,43 @@ def main_callback(
 ) -> None:
     # Only run interactive mode when no subcommand is invoked
     if ctx.invoked_subcommand is None:
+        from klaude_code.trace import log
+
+        resume_by_id_value = resume_by_id.strip() if resume_by_id is not None else None
+        if resume_by_id_value == "":
+            log(("Error: --resume-by-id cannot be empty", "red"))
+            raise typer.Exit(2)
+
+        if resume_by_id_value is not None and (resume or continue_):
+            log(("Error: --resume-by-id cannot be combined with --resume/--continue", "red"))
+            raise typer.Exit(2)
+
+        if resume_by_id_value is not None and not Session.exists(resume_by_id_value):
+            log((f"Error: session id '{resume_by_id_value}' not found for this project", "red"))
+            log(("Hint: run `klaude --resume` to select an existing session", "yellow"))
+            raise typer.Exit(2)
+
+        # In non-interactive environments, default to exec-mode behavior.
+        # This allows: echo "..." | klaude
+        if not sys.stdin.isatty() or not sys.stdout.isatty():
+            if continue_ or resume or resume_by_id is not None:
+                log(("Error: --continue/--resume options require a TTY", "red"))
+                log(("Hint: use `klaude exec` for non-interactive usage", "yellow"))
+                raise typer.Exit(2)
+
+            exec_command(
+                input_content="",
+                model=model,
+                select_model=select_model,
+                debug=debug,
+                debug_filter=debug_filter,
+                vanilla=vanilla,
+                stream_json=False,
+            )
+            return
+
         from klaude_code.cli.runtime import AppInitConfig, run_interactive
         from klaude_code.config.select_model import select_model_from_config
-        from klaude_code.trace import log
 
         update_terminal_title()
 
@@ -258,15 +296,6 @@ def main_callback(
         # session_id=None means create a new session
         session_id: str | None = None
 
-        resume_by_id_value = resume_by_id.strip() if resume_by_id is not None else None
-        if resume_by_id_value == "":
-            log(("Error: --resume-by-id cannot be empty", "red"))
-            raise typer.Exit(2)
-
-        if resume_by_id_value is not None and (resume or continue_):
-            log(("Error: --resume-by-id cannot be combined with --resume/--continue", "red"))
-            raise typer.Exit(2)
-
         if resume:
             session_id = resume_select_session()
             if session_id is None:
@@ -276,10 +305,6 @@ def main_callback(
             session_id = Session.most_recent_session_id()
 
         if resume_by_id_value is not None:
-            if not Session.exists(resume_by_id_value):
-                log((f"Error: session id '{resume_by_id_value}' not found for this project", "red"))
-                log(("Hint: run `klaude --resume` to select an existing session", "yellow"))
-                raise typer.Exit(2)
             session_id = resume_by_id_value
         # If still no session_id, leave as None to create a new session
 

klaude_code/cli/runtime.py

@@ -255,12 +255,8 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
 
     # Create status provider for bottom toolbar
     def _status_provider() -> REPLStatusSnapshot:
-        # Check for updates (returns None if uv not available)
         update_message = get_update_message()
-
-        return build_repl_status_snapshot(
-            agent=components.executor.context.current_agent, update_message=update_message
-        )
+        return build_repl_status_snapshot(update_message)
 
     # Set up input provider for interactive mode
     def _stop_rich_bottom_ui() -> None:
@@ -276,9 +272,19 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             display.wrapped_display.renderer.spinner_stop()
             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
+    # can interfere with prompt_toolkit's terminal state and break history navigation.
+    is_light_background: bool | None = None
+    if components.theme == "light":
+        is_light_background = True
+    elif components.theme == "dark":
+        is_light_background = False
+
     input_provider: ui.InputProviderABC = ui.PromptToolkitInput(
         status_provider=_status_provider,
         pre_prompt=_stop_rich_bottom_ui,
+        is_light_background=is_light_background,
     )
 
     # --- Custom Ctrl+C handler: double-press within 2s to exit, single press shows toast ---

klaude_code/command/__init__.py

@@ -31,6 +31,7 @@ def ensure_commands_loaded() -> None:
     from .debug_cmd import DebugCommand
     from .export_cmd import ExportCommand
     from .export_online_cmd import ExportOnlineCommand
+    from .fork_session_cmd import ForkSessionCommand
     from .help_cmd import HelpCommand
     from .model_cmd import ModelCommand
     from .refresh_cmd import RefreshTerminalCommand
@@ -45,6 +46,7 @@ def ensure_commands_loaded() -> None:
     register(RefreshTerminalCommand())
     register(ThinkingCommand())
     register(ModelCommand())
+    register(ForkSessionCommand())
     load_prompt_commands()
     register(StatusCommand())
     register(HelpCommand())
@@ -63,6 +65,7 @@ def __getattr__(name: str) -> object:
         "DebugCommand": "debug_cmd",
         "ExportCommand": "export_cmd",
         "ExportOnlineCommand": "export_online_cmd",
+        "ForkSessionCommand": "fork_session_cmd",
         "HelpCommand": "help_cmd",
         "ModelCommand": "model_cmd",
         "RefreshTerminalCommand": "refresh_cmd",

klaude_code/command/export_online_cmd.py

@@ -47,20 +47,23 @@ class ExportOnlineCommand(CommandABC):
             )
             return CommandResult(events=[event])
 
-        # Check if user is logged in to surge
-        if not self._is_surge_logged_in(surge_cmd):
-            login_cmd = " ".join([*surge_cmd, "login"])
-            event = events.DeveloperMessageEvent(
-                session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content=f"Not logged in to surge.sh. Please run: {login_cmd}",
-                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
-                ),
-            )
-            return CommandResult(events=[event])
-
         try:
             console = Console()
+            # Check login status inside status context since npx surge whoami can be slow
+            with console.status(Text("Checking surge.sh login status...", style="dim"), spinner_style="dim"):
+                logged_in = self._is_surge_logged_in(surge_cmd)
+
+            if not logged_in:
+                login_cmd = " ".join([*surge_cmd, "login"])
+                event = events.DeveloperMessageEvent(
+                    session_id=agent.session.id,
+                    item=model.DeveloperMessageItem(
+                        content=f"Not logged in to surge.sh. Please run: {login_cmd}",
+                        command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                    ),
+                )
+                return CommandResult(events=[event])
+
             with console.status(Text("Deploying to surge.sh...", style="dim"), spinner_style="dim"):
                 html_doc = self._build_html(agent)
                 domain = self._generate_domain()

klaude_code/command/fork_session_cmd.py

@@ -0,0 +1,42 @@
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
+
+
+class ForkSessionCommand(CommandABC):
+    """Fork current session to a new session id and show a resume command."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.FORK_SESSION
+
+    @property
+    def summary(self) -> str:
+        return "Fork the current session and show a resume-by-id command"
+
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+
+        if agent.session.messages_count == 0:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(no messages to fork)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event])
+
+        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])

klaude_code/config/select_model.py

@@ -96,6 +96,7 @@ def select_model_from_config(preferred: str | None = None) -> str | None:
         else:
             # No matches: show all models without filter hint
             preferred = None
+            log(("No matching models found. Showing all models.", "yellow"))
 
     # Non-interactive environments (CI/pipes) should never enter an interactive prompt.
     # If we couldn't resolve to a single model deterministically above, fail with a clear hint.

klaude_code/core/executor.py

@@ -404,7 +404,8 @@ class ExecutorContext:
 
     def _open_file(self, path: Path) -> None:
         try:
-            subprocess.run(["open", str(path)], check=True)
+            # Detach stdin to prevent interference with prompt_toolkit's terminal state
+            subprocess.run(["open", str(path)], stdin=subprocess.DEVNULL, check=True)
         except FileNotFoundError as exc:  # pragma: no cover
             msg = "`open` command not found; please open the HTML manually."
             raise RuntimeError(msg) from exc

klaude_code/core/reminders.py

@@ -46,6 +46,17 @@ class AtPatternSource:
     mentioned_in: str | None = None
 
 
+def _extract_at_patterns(content: str) -> list[str]:
+    """Extract @ patterns from content."""
+    patterns: list[str] = []
+    if "@" in content:
+        for match in AT_FILE_PATTERN.finditer(content):
+            path_str = match.group("quoted") or match.group("plain")
+            if path_str:
+                patterns.append(path_str)
+    return patterns
+
+
 def get_at_patterns_with_source(session: Session) -> list[AtPatternSource]:
     """Get @ patterns from last user input and developer messages, preserving source info."""
     patterns: list[AtPatternSource] = []
@@ -56,24 +67,14 @@ def get_at_patterns_with_source(session: Session) -> list[AtPatternSource]:
 
         if isinstance(item, model.UserMessageItem):
             content = item.content or ""
-            if "@" in content:
-                for match in AT_FILE_PATTERN.finditer(content):
-                    path_str = match.group("quoted") or match.group("plain")
-                    if path_str:
-                        patterns.append(AtPatternSource(pattern=path_str, mentioned_in=None))
+            for path_str in _extract_at_patterns(content):
+                patterns.append(AtPatternSource(pattern=path_str, mentioned_in=None))
             break
 
-        if isinstance(item, model.DeveloperMessageItem):
-            content = item.content or ""
-            if "@" not in content:
-                continue
-            # Use first memory_path as the source if available
-            source = item.memory_paths[0] if item.memory_paths else None
-            for match in AT_FILE_PATTERN.finditer(content):
-                path_str = match.group("quoted") or match.group("plain")
-                if path_str:
-                    patterns.append(AtPatternSource(pattern=path_str, mentioned_in=source))
-
+        if isinstance(item, model.DeveloperMessageItem) and item.memory_mentioned:
+            for memory_path, mentioned_patterns in item.memory_mentioned.items():
+                for pattern in mentioned_patterns:
+                    patterns.append(AtPatternSource(pattern=pattern, mentioned_in=memory_path))
     return patterns
 
 
@@ -92,6 +93,23 @@ def get_skill_from_user_input(session: Session) -> str | None:
     return None
 
 
+def _is_tracked_file_unchanged(session: Session, path: str) -> bool:
+    status = session.file_tracker.get(path)
+    if status is None or status.content_sha256 is None:
+        return False
+
+    try:
+        current_mtime = Path(path).stat().st_mtime
+    except (OSError, FileNotFoundError):
+        return False
+
+    if current_mtime == status.mtime:
+        return True
+
+    current_sha256 = _compute_file_content_sha256(path)
+    return current_sha256 is not None and current_sha256 == status.content_sha256
+
+
 async def _load_at_file_recursive(
     session: Session,
     pattern: str,
@@ -112,6 +130,8 @@ async def _load_at_file_recursive(
     context_token = set_tool_context_from_session(session)
     try:
         if path.exists() and path.is_file():
+            if _is_tracked_file_unchanged(session, path_str):
+                return
             args = ReadTool.ReadArguments(file_path=path_str)
             tool_result = await ReadTool.call_with_args(args)
             at_files[path_str] = model.AtPatternParseResult(
@@ -458,6 +478,13 @@ async def memory_reminder(session: Session) -> model.DeveloperMessageItem | None
         memories_str = "\n\n".join(
             [f"Contents of {memory.path} ({memory.instruction}):\n\n{memory.content}" for memory in memories]
         )
+        # Build memory_mentioned: extract @ patterns from each memory's content
+        memory_mentioned: dict[str, list[str]] = {}
+        for memory in memories:
+            patterns = _extract_at_patterns(memory.content)
+            if patterns:
+                memory_mentioned[memory.path] = patterns
+
         return model.DeveloperMessageItem(
             content=f"""<system-reminder>As you answer the user's questions, you can use the following context:
 
@@ -474,6 +501,7 @@ NEVER proactively create documentation files (*.md) or README files. Only create
 IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.
 </system-reminder>""",
             memory_paths=[memory.path for memory in memories],
+            memory_mentioned=memory_mentioned or None,
         )
     return None
 
@@ -544,10 +572,18 @@ async def last_path_memory_reminder(
         memories_str = "\n\n".join(
             [f"Contents of {memory.path} ({memory.instruction}):\n\n{memory.content}" for memory in memories]
         )
+        # Build memory_mentioned: extract @ patterns from each memory's content
+        memory_mentioned: dict[str, list[str]] = {}
+        for memory in memories:
+            patterns = _extract_at_patterns(memory.content)
+            if patterns:
+                memory_mentioned[memory.path] = patterns
+
         return model.DeveloperMessageItem(
             content=f"""<system-reminder>{memories_str}
 </system-reminder>""",
             memory_paths=[memory.path for memory in memories],
+            memory_mentioned=memory_mentioned or None,
         )
 
 

klaude_code/core/tool/web/mermaid_tool.md

@@ -45,3 +45,20 @@ sequenceDiagram
 
 # Styling
 - When defining custom classDefs, always define fill color, stroke color, and text color ("fill", "stroke", "color") explicitly
+- Use colors to distinguish node types and improve readability
+
+## Color Palette
+- Cyan #e0f0f0 - information, data flow
+- Green #e0f0e0 - success, completion
+- Blue #e0e8f5 - primary actions, main flow
+- Purple #ede0f5 - highlights, special nodes
+- Orange #f5ebe0 - warnings, pending
+- Red #f5e0e0 - errors, critical
+- Grey #e8e8e8 - neutral elements
+- Yellow #f5f5e0 - attention, notes
+
+Example:
+```mermaid
+classDef primary fill:#e0e8f5,stroke:#3078C5,color:#1a1a1a
+classDef success fill:#e0f0e0,stroke:#00875f,color:#1a1a1a
+```

klaude_code/core/tool/web/mermaid_tool.py

@@ -11,7 +11,7 @@ from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
-_MERMAID_LIVE_PREFIX = "https://mermaid.live/view#pako:"
+_MERMAID_LIVE_PREFIX = "https://mermaid.live/edit#pako:"
 
 
 @register(tools.MERMAID)
@@ -31,7 +31,7 @@ class MermaidTool(ToolABC):
                 "type": "object",
                 "properties": {
                     "code": {
-                        "description": "The Mermaid diagram code to render (DO NOT override with custom colors or other styles, DO NOT use HTML tags in node labels)",
+                        "description": "The Mermaid diagram code to render (DO NOT use HTML tags in node labels)",
                         "type": "string",
                     },
                 },

klaude_code/llm/openai_compatible/tool_call_accumulator.py

@@ -1,9 +1,25 @@
+import re
 from abc import ABC, abstractmethod
 
 from openai.types.chat.chat_completion_chunk import ChoiceDeltaToolCall
 from pydantic import BaseModel, Field
 
 from klaude_code.protocol import model
+from klaude_code.trace.log import log_debug
+
+
+def normalize_tool_name(name: str) -> str:
+    """Normalize tool name from Gemini-3 format.
+
+    Gemini-3 sometimes returns tool names in format like 'tool_Edit_mUoY2p3W3r3z8uO5P2nZ'.
+    This function extracts the actual tool name (e.g., 'Edit').
+    """
+    match = re.match(r"^tool_([A-Za-z]+)_[A-Za-z0-9]+$", name)
+    if match:
+        normalized = match.group(1)
+        log_debug(f"Gemini-3 tool name normalized: {name} -> {normalized}", style="yellow")
+        return normalized
+    return name
 
 
 class ToolCallAccumulatorABC(ABC):
@@ -74,7 +90,7 @@ class BasicToolCallAccumulator(ToolCallAccumulatorABC, BaseModel):
             if first_chunk.function is None:
                 continue
             if first_chunk.function.name:
-                result[-1].name = first_chunk.function.name
+                result[-1].name = normalize_tool_name(first_chunk.function.name)
             if first_chunk.function.arguments:
                 result[-1].arguments += first_chunk.function.arguments
         return result

klaude_code/protocol/commands.py

@@ -15,6 +15,7 @@ class CommandName(str, Enum):
     STATUS = "status"
     RELEASE_NOTES = "release-notes"
     THINKING = "thinking"
+    FORK_SESSION = "fork-session"
     # PLAN and DOC are dynamically registered now, but kept here if needed for reference
     # or we can remove them if no code explicitly imports them.
     # PLAN = "plan"

klaude_code/protocol/model.py

@@ -260,6 +260,7 @@ class DeveloperMessageItem(BaseModel):
 
     # Special fields for reminders UI
     memory_paths: list[str] | None = None
+    memory_mentioned: dict[str, list[str]] | None = None  # memory_path -> list of @ patterns mentioned in it
     external_file_changes: list[str] | None = None
     todo_use: bool | None = None
     at_files: list[AtPatternParseResult] | None = None

klaude_code/session/export.py

@@ -427,6 +427,41 @@ def _get_diff_ui_extra(ui_extra: model.ToolResultUIExtra | None) -> model.DiffUI
     return None
 
 
+def _render_markdown_doc(doc: model.MarkdownDocUIExtra) -> str:
+    encoded = _escape_html(doc.content)
+    file_path = _escape_html(doc.file_path)
+    header = f'<div class="diff-file">{file_path} <span style="font-weight: normal; color: var(--text-dim); font-size: 12px; margin-left: 8px;">(markdown content)</span></div>'
+
+    # Using a container that mimics diff-view but for markdown
+    content = (
+        f'<div class="markdown-content markdown-body" data-raw="{encoded}" '
+        f'style="padding: 12px; border: 1px solid var(--border); border-radius: var(--radius-md); background: var(--bg-body); margin-top: 4px;">'
+        f'<noscript><pre style="white-space: pre-wrap;">{encoded}</pre></noscript>'
+        f"</div>"
+    )
+
+    line_count = doc.content.count("\n") + 1
+    open_attr = " open"
+
+    return (
+        f'<details class="diff-collapsible"{open_attr}>'
+        f"<summary>File Content ({line_count} lines)</summary>"
+        f'<div style="margin-top: 8px;">'
+        f"{header}"
+        f"{content}"
+        f"</div>"
+        f"</details>"
+    )
+
+
+def _collect_ui_extras(ui_extra: model.ToolResultUIExtra | None) -> list[model.ToolResultUIExtra]:
+    if ui_extra is None:
+        return []
+    if isinstance(ui_extra, model.MultiUIExtra):
+        return list(ui_extra.items)
+    return [ui_extra]
+
+
 def _build_add_only_diff(text: str, file_path: str) -> model.DiffUIExtra:
     lines: list[model.DiffLine] = []
     new_line_no = 1
@@ -567,19 +602,26 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
     ]
 
     if result:
-        diff_ui = _get_diff_ui_extra(result.ui_extra)
-        mermaid_html = _get_mermaid_link_html(result.ui_extra, tool_call)
+        extras = _collect_ui_extras(result.ui_extra)
+
+        mermaid_extra = next((x for x in extras if isinstance(x, model.MermaidLinkUIExtra)), None)
+        mermaid_source = mermaid_extra if mermaid_extra else result.ui_extra
+        mermaid_html = _get_mermaid_link_html(mermaid_source, tool_call)
 
         should_hide_text = tool_call.name in ("TodoWrite", "update_plan") and result.status != "error"
 
-        if tool_call.name == "Edit" and not diff_ui and result.status != "error":
+        if (
+            tool_call.name == "Edit"
+            and not any(isinstance(x, model.DiffUIExtra) for x in extras)
+            and result.status != "error"
+        ):
             try:
                 args_data = json.loads(tool_call.arguments)
                 file_path = args_data.get("file_path", "Unknown file")
                 old_string = args_data.get("old_string", "")
                 new_string = args_data.get("new_string", "")
                 if old_string == "" and new_string:
-                    diff_ui = _build_add_only_diff(new_string, file_path)
+                    extras.append(_build_add_only_diff(new_string, file_path))
             except (json.JSONDecodeError, TypeError):
                 pass
 
@@ -591,8 +633,11 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
             else:
                 items_to_render.append(_render_text_block(result.output))
 
-        if diff_ui:
-            items_to_render.append(_render_diff_block(diff_ui))
+        for extra in extras:
+            if isinstance(extra, model.DiffUIExtra):
+                items_to_render.append(_render_diff_block(extra))
+            elif isinstance(extra, model.MarkdownDocUIExtra):
+                items_to_render.append(_render_markdown_doc(extra))
 
         if mermaid_html:
             items_to_render.append(mermaid_html)

klaude_code/session/session.py

@@ -197,6 +197,28 @@ 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:
+        """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.
+        """
+
+        forked = Session.create(id=new_id, work_dir=self.work_dir)
+
+        forked.sub_agent_state = None
+        forked.model_name = self.model_name
+        forked.model_config_name = self.model_config_name
+        forked.model_thinking = self.model_thinking.model_copy(deep=True) if self.model_thinking is not None else None
+        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 = [cast(model.ConversationItem, it.model_copy(deep=True)) for it in self.conversation_history]
+        if items:
+            forked.append_history(items)
+
+        return forked
+
     async def wait_for_flush(self) -> None:
         await self._store.wait_for_flush(self.id)
 

klaude_code/trace/log.py

@@ -302,6 +302,12 @@ def _trash_path(path: Path) -> None:
     """Send a path to trash, falling back to unlink if trash is unavailable."""
 
     try:
-        subprocess.run(["trash", str(path)], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        subprocess.run(
+            ["trash", str(path)],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
     except FileNotFoundError:
         path.unlink(missing_ok=True)

klaude_code/ui/modes/repl/__init__.py

@@ -1,47 +1,6 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from klaude_code.protocol import model
 from klaude_code.ui.modes.repl.input_prompt_toolkit import REPLStatusSnapshot
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
-
-def build_repl_status_snapshot(agent: Agent | None, update_message: str | None) -> REPLStatusSnapshot:
-    """Build a status snapshot for the REPL bottom toolbar.
-
-    Aggregates model name, context usage, and basic call counts from the
-    provided agent's session history.
-    """
-
-    model_name = ""
-    context_usage_percent: float | None = None
-    llm_calls = 0
-    tool_calls = 0
-
-    if agent is not None:
-        model_name = agent.profile.llm_client.model_name or ""
-
-        history = agent.session.conversation_history
-        for item in history:
-            if isinstance(item, model.AssistantMessageItem):
-                llm_calls += 1
-            elif isinstance(item, model.ToolCallItem):
-                tool_calls += 1
-
-        for item in reversed(history):
-            if isinstance(item, model.ResponseMetadataItem):
-                usage = item.usage
-                if usage is not None and hasattr(usage, "context_usage_percent"):
-                    context_usage_percent = usage.context_usage_percent
-                break
 
-    return REPLStatusSnapshot(
-        model_name=model_name,
-        context_usage_percent=context_usage_percent,
-        llm_calls=llm_calls,
-        tool_calls=tool_calls,
-        update_message=update_message,
-    )
+def build_repl_status_snapshot(update_message: str | None) -> REPLStatusSnapshot:
+    """Build a status snapshot for the REPL bottom toolbar."""
+    return REPLStatusSnapshot(update_message=update_message)