klaude-code 2.0.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

klaude_code/core/tool/file/edit_tool.py

@@ -8,6 +8,7 @@ from pathlib import Path
 
 from pydantic import BaseModel, Field
 
+from klaude_code.const import DIFF_DEFAULT_CONTEXT_LINES
 from klaude_code.core.tool.file._utils import file_exists, hash_text_sha256, is_directory, read_text, write_text
 from klaude_code.core.tool.file.diff_builder import build_structured_diff
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
@@ -191,14 +192,14 @@ class EditTool(ToolABC):
         except (OSError, UnicodeError) as e:  # pragma: no cover
             return message.ToolResultMessage(status="error", output_text=f"<tool_use_error>{e}</tool_use_error>")
 
-        # Prepare UI extra: unified diff with 3 context lines
+        # Prepare UI extra: unified diff with default context lines
         diff_lines = list(
             difflib.unified_diff(
                 before.splitlines(),
                 after.splitlines(),
                 fromfile=file_path,
                 tofile=file_path,
-                n=3,
+                n=DIFF_DEFAULT_CONTEXT_LINES,
             )
         )
         ui_extra = build_structured_diff(before, after, file_path=file_path)

klaude_code/core/tool/todo/todo_write_tool.py

@@ -63,9 +63,8 @@ class TodoWriteTool(ToolABC):
                                     "type": "string",
                                     "enum": ["pending", "in_progress", "completed"],
                                 },
-                                "activeForm": {"type": "string", "minLength": 1},
                             },
-                            "required": ["content", "status", "activeForm"],
+                            "required": ["content", "status"],
                             "additionalProperties": False,
                         },
                         "description": "The updated todo list",

klaude_code/core/tool/tool_registry.py

@@ -66,11 +66,11 @@ def load_agent_tools(
 
     # Main agent tools
     if "gpt-5" in model_name:
-        tool_names = [tools.BASH, tools.READ, tools.APPLY_PATCH, tools.MOVE, tools.UPDATE_PLAN]
+        tool_names = [tools.BASH, tools.READ, tools.APPLY_PATCH, tools.UPDATE_PLAN]
     elif "gemini-3" in model_name:
-        tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.MOVE]
+        tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE]
     else:
-        tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.MOVE, tools.TODO_WRITE]
+        tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.TODO_WRITE]
 
     tool_names.extend(sub_agent_tool_names(enabled_only=True, model_name=model_name))
     tool_names.extend([tools.SKILL, tools.MERMAID])

klaude_code/protocol/events.py

@@ -127,6 +127,7 @@ class UserMessageEvent(BaseModel):
 class WelcomeEvent(BaseModel):
     work_dir: str
     llm_config: llm_param.LLMConfigParameter
+    show_klaude_code_info: bool = True
 
 
 class InterruptEvent(BaseModel):

klaude_code/protocol/message.py

@@ -12,8 +12,7 @@ from typing import Annotated, Literal
 from pydantic import BaseModel, Field, field_validator
 
 from klaude_code.protocol.model import (
-    AtPatternParseResult,
-    CommandOutput,
+    DeveloperUIExtra,
     StopReason,
     TaskMetadata,
     TaskMetadataItem,
@@ -137,15 +136,8 @@ class DeveloperMessage(MessageBase):
     role: Literal["developer"] = "developer"
     parts: list[Part]
 
-    # 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
-    command_output: CommandOutput | None = None
-    user_image_count: int | None = None
-    skill_name: str | None = None  # Skill name activated via $skill syntax
+    # Structured UI-only metadata (never sent to the LLM).
+    ui_extra: DeveloperUIExtra | None = None
 
 
 class UserMessage(MessageBase):

klaude_code/protocol/model.py

@@ -2,7 +2,7 @@ from datetime import datetime
 from enum import Enum
 from typing import Annotated, Any, Literal
 
-from pydantic import BaseModel, ConfigDict, Field, computed_field
+from pydantic import BaseModel, Field, computed_field
 
 from klaude_code.const import DEFAULT_MAX_TOKENS
 from klaude_code.protocol.commands import CommandName
@@ -150,11 +150,8 @@ class TaskMetadataItem(BaseModel):
 
 
 class TodoItem(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-
     content: str
     status: TodoStatusType
-    active_form: str = Field(default="", alias="activeForm")
 
 
 class FileStatus(BaseModel):
@@ -275,21 +272,90 @@ ToolResultUIExtra = Annotated[
 ]
 
 
-class AtPatternParseResult(BaseModel):
-    path: str
-    tool_name: str
-    result: str
-    tool_args: str
-    operation: Literal["Read", "List"]
-    mentioned_in: str | None = None  # Parent file that referenced this file
-
-
 class CommandOutput(BaseModel):
     command_name: CommandName
     ui_extra: ToolResultUIExtra | None = None
     is_error: bool = False
 
 
+class MemoryFileLoaded(BaseModel):
+    path: str
+    mentioned_patterns: list[str] = Field(default_factory=list)
+
+
+class MemoryLoadedUIItem(BaseModel):
+    type: Literal["memory_loaded"] = "memory_loaded"
+    files: list[MemoryFileLoaded]
+
+
+class ExternalFileChangesUIItem(BaseModel):
+    type: Literal["external_file_changes"] = "external_file_changes"
+    paths: list[str]
+
+
+class TodoReminderUIItem(BaseModel):
+    type: Literal["todo_reminder"] = "todo_reminder"
+    reason: Literal["empty", "not_used_recently"]
+
+
+class AtFileOp(BaseModel):
+    operation: Literal["Read", "List"]
+    path: str
+    mentioned_in: str | None = None
+
+
+class AtFileOpsUIItem(BaseModel):
+    type: Literal["at_file_ops"] = "at_file_ops"
+    ops: list[AtFileOp]
+
+
+class UserImagesUIItem(BaseModel):
+    type: Literal["user_images"] = "user_images"
+    count: int
+
+
+class SkillActivatedUIItem(BaseModel):
+    type: Literal["skill_activated"] = "skill_activated"
+    name: str
+
+
+class CommandOutputUIItem(BaseModel):
+    type: Literal["command_output"] = "command_output"
+    output: CommandOutput
+
+
+type DeveloperUIItem = (
+    MemoryLoadedUIItem
+    | ExternalFileChangesUIItem
+    | TodoReminderUIItem
+    | AtFileOpsUIItem
+    | UserImagesUIItem
+    | SkillActivatedUIItem
+    | CommandOutputUIItem
+)
+
+
+def _empty_developer_ui_items() -> list[DeveloperUIItem]:
+    return []
+
+
+class DeveloperUIExtra(BaseModel):
+    items: list[DeveloperUIItem] = Field(default_factory=_empty_developer_ui_items)
+
+
+def build_command_output_extra(
+    command_name: CommandName,
+    *,
+    ui_extra: ToolResultUIExtra | None = None,
+    is_error: bool = False,
+) -> DeveloperUIExtra:
+    return DeveloperUIExtra(
+        items=[
+            CommandOutputUIItem(output=CommandOutput(command_name=command_name, ui_extra=ui_extra, is_error=is_error))
+        ]
+    )
+
+
 class SubAgentState(BaseModel):
     sub_agent_type: SubAgentType
     sub_agent_desc: str

klaude_code/protocol/op.py

@@ -23,7 +23,6 @@ if TYPE_CHECKING:
 class OperationType(Enum):
     """Enumeration of supported operation types."""
 
-    USER_INPUT = "user_input"
     RUN_AGENT = "run_agent"
     CHANGE_MODEL = "change_model"
     CHANGE_THINKING = "change_thinking"
@@ -46,18 +45,6 @@ class Operation(BaseModel):
         raise NotImplementedError("Subclasses must implement execute()")
 
 
-class UserInputOperation(Operation):
-    """Operation for handling user input (text and optional images) that should be processed by an agent."""
-
-    type: OperationType = OperationType.USER_INPUT
-    input: UserInputPayload
-    session_id: str | None = None
-
-    async def execute(self, handler: OperationHandler) -> None:
-        """Execute user input by running it through an agent."""
-        await handler.handle_user_input(self)
-
-
 class RunAgentOperation(Operation):
     """Operation for launching an agent task for a given session."""
 

klaude_code/protocol/op_handler.py

@@ -18,17 +18,12 @@ if TYPE_CHECKING:
         InterruptOperation,
         ResumeSessionOperation,
         RunAgentOperation,
-        UserInputOperation,
     )
 
 
 class OperationHandler(Protocol):
     """Protocol defining the interface for handling operations."""
 
-    async def handle_user_input(self, operation: UserInputOperation) -> None:
-        """Handle a user input operation."""
-        ...
-
     async def handle_run_agent(self, operation: RunAgentOperation) -> None:
         """Handle a run agent operation."""
         ...

klaude_code/protocol/sub_agent/explore.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Any
-
 from klaude_code.protocol import tools
 from klaude_code.protocol.sub_agent import SubAgentProfile, register_sub_agent
 
@@ -37,11 +35,6 @@ EXPLORE_PARAMETERS = {
             "type": "string",
             "description": "The task for the agent to perform",
         },
-        "thoroughness": {
-            "type": "string",
-            "enum": ["quick", "medium", "very thorough"],
-            "description": "Controls how deep the sub-agent should search the repo",
-        },
         "output_format": {
             "type": "object",
             "description": "Optional JSON Schema for sub-agent structured output",
@@ -52,13 +45,6 @@ EXPLORE_PARAMETERS = {
 }
 
 
-def _explore_prompt_builder(args: dict[str, Any]) -> str:
-    """Build the Explore prompt from tool arguments."""
-    prompt = args.get("prompt", "").strip()
-    thoroughness = args.get("thoroughness", "medium")
-    return f"{prompt}\nthoroughness: {thoroughness}"
-
-
 register_sub_agent(
     SubAgentProfile(
         name="Explore",
@@ -66,7 +52,6 @@ register_sub_agent(
         parameters=EXPLORE_PARAMETERS,
         prompt_file="prompts/prompt-sub-agent-explore.md",
         tool_set=(tools.BASH, tools.READ),
-        prompt_builder=_explore_prompt_builder,
         active_form="Exploring",
         output_schema_arg="output_format",
     )

klaude_code/protocol/sub_agent/task.py

@@ -64,7 +64,7 @@ register_sub_agent(
         description=TASK_DESCRIPTION,
         parameters=TASK_PARAMETERS,
         prompt_file="prompts/prompt-sub-agent.md",
-        tool_set=(tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.MOVE),
+        tool_set=(tools.BASH, tools.READ, tools.EDIT, tools.WRITE),
         active_form="Tasking",
         output_schema_arg="output_format",
     )

klaude_code/protocol/sub_agent/web.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Any
-
 from klaude_code.protocol import tools
 from klaude_code.protocol.sub_agent import SubAgentProfile, register_sub_agent
 
@@ -21,7 +19,7 @@ Capabilities:
 How to use:
 - Write a clear prompt describing what information you need - the agent will search and fetch as needed
 - Account for "Today's date" in <env>. For example, if <env> says "Today's date: 2025-07-01", and the user wants the latest docs, do not use 2024 in the search query. Use 2025.
-- Optionally provide a `url` if you already know the target page
+- Provide the url if you already know the target page
 - Use `output_format` (JSON Schema) to get structured data back from the agent
 
 What you receive:
@@ -48,10 +46,6 @@ WEB_AGENT_PARAMETERS = {
             "type": "string",
             "description": "A short (3-5 word) description of the task",
         },
-        "url": {
-            "type": "string",
-            "description": "The URL to fetch and analyze. If not provided, the agent will search the web first",
-        },
         "prompt": {
             "type": "string",
             "description": "Instructions for searching, analyzing, or extracting content from the web page",
@@ -66,15 +60,6 @@ WEB_AGENT_PARAMETERS = {
 }
 
 
-def _web_agent_prompt_builder(args: dict[str, Any]) -> str:
-    """Build the WebAgent prompt from tool arguments."""
-    url = args.get("url", "")
-    prompt = args.get("prompt", "")
-    if url:
-        return f"URL to fetch: {url}\nTask: {prompt}"
-    return prompt
-
-
 register_sub_agent(
     SubAgentProfile(
         name="WebAgent",
@@ -82,7 +67,6 @@ register_sub_agent(
         parameters=WEB_AGENT_PARAMETERS,
         prompt_file="prompts/prompt-sub-agent-web.md",
         tool_set=(tools.BASH, tools.READ, tools.WEB_FETCH, tools.WEB_SEARCH, tools.WRITE),
-        prompt_builder=_web_agent_prompt_builder,
         active_form="Surfing",
         output_schema_arg="output_format",
     )

klaude_code/protocol/tools.py

@@ -1,6 +1,5 @@
 BASH = "Bash"
 APPLY_PATCH = "apply_patch"
-MOVE = "Move"
 EDIT = "Edit"
 
 READ = "Read"

klaude_code/ui/modes/exec/display.py

@@ -14,12 +14,11 @@ class ExecDisplay(DisplayABC):
         """Only handle TaskFinishEvent."""
         match event:
             case events.TaskStartEvent():
-                emit_osc94(OSC94States.INDETERMINATE)
+                pass
             case events.ErrorEvent() as e:
-                emit_osc94(OSC94States.HIDDEN)
+                emit_osc94(OSC94States.ERROR)
                 print(f"Error: {e.error_message}")
             case events.TaskFinishEvent() as e:
-                emit_osc94(OSC94States.HIDDEN)
                 # Print the task result when task finishes
                 if e.task_result.strip():
                     print(e.task_result)

klaude_code/ui/modes/repl/display.py

@@ -19,7 +19,7 @@ class REPLDisplay(DisplayABC):
     - Syntax-highlighted code blocks and diffs
     - Animated spinners for in-progress operations
     - Tool call and result visualization
-    - OSC94 progress bar integration (for supported terminals)
+    - OSC94 error indicator (for supported terminals)
     - Desktop notifications on task completion
 
     This is the primary display mode for interactive klaude-code sessions.

klaude_code/ui/modes/repl/event_handler.py

@@ -416,14 +416,12 @@ class DisplayEventHandler:
             self._sub_agent_thinking_headers[event.session_id] = SubAgentThinkingHeaderState()
         self.renderer.spinner_start()
         self.renderer.display_task_start(event)
-        emit_osc94(OSC94States.INDETERMINATE)
 
     def _on_developer_message(self, event: events.DeveloperMessageEvent) -> None:
         self.renderer.display_developer_message(event)
         self.renderer.display_command_output(event)
 
     def _on_turn_start(self, event: events.TurnStartEvent) -> None:
-        emit_osc94(OSC94States.INDETERMINATE)
         self.renderer.display_turn_start(event)
         self.spinner_status.clear_for_new_turn()
         self.spinner_status.set_reasoning_status(None)
@@ -533,7 +531,6 @@ class DisplayEventHandler:
         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()
             self.renderer.console.print(Rule(characters="─", style=ThemeKey.LINES))
@@ -548,7 +545,6 @@ class DisplayEventHandler:
         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()
 
     async def _on_error(self, event: events.ErrorEvent) -> None:
@@ -560,7 +556,6 @@ class DisplayEventHandler:
             self.spinner_status.reset()
 
     async def _on_end(self, event: events.EndEvent) -> None:
-        emit_osc94(OSC94States.HIDDEN)
         await self.stage_manager.transition_to(Stage.WAITING)
         self.renderer.spinner_stop()
         self.spinner_status.reset()
@@ -624,11 +619,8 @@ class DisplayEventHandler:
     def _extract_active_form_text(self, todo_event: events.TodoChangeEvent) -> str | None:
         status_text: str | None = None
         for todo in todo_event.todos:
-            if todo.status == "in_progress":
-                if len(todo.active_form) > 0:
-                    status_text = todo.active_form
-                if len(todo.content) > 0:
-                    status_text = todo.content
+            if todo.status == "in_progress" and len(todo.content) > 0:
+                status_text = todo.content
 
         if status_text is None:
             return None

klaude_code/ui/modes/repl/input_prompt_toolkit.py

@@ -314,7 +314,7 @@ class PromptToolkitInput(InputProviderABC):
                     "question": "bold",
                     "msg": "",
                     "meta": "fg:ansibrightblack",
-                    "frame.border": "fg:ansibrightblack",
+                    "frame.border": "fg:ansibrightblack dim",
                     "search_prefix": "fg:ansibrightblack",
                     "search_placeholder": "fg:ansibrightblack italic",
                     "search_input": "",
@@ -604,6 +604,10 @@ class PromptToolkitInput(InputProviderABC):
                 (symbol_style, " ctrl-l "),
                 (text_style, " "),
                 (text_style, "models"),
+                (text_style, "  "),
+                (symbol_style, " ctrl-t "),
+                (text_style, " "),
+                (text_style, "think"),
             ]
         )
 

klaude_code/ui/modes/repl/key_bindings.py

@@ -11,8 +11,9 @@ import re
 from collections.abc import Callable
 from typing import cast
 
+from prompt_toolkit.application.current import get_app
 from prompt_toolkit.buffer import Buffer
-from prompt_toolkit.filters import Always, Filter
+from prompt_toolkit.filters import Always, Condition, Filter
 from prompt_toolkit.filters.app import has_completions
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.key_binding.key_processor import KeyPressEvent
@@ -40,6 +41,119 @@ def create_key_bindings(
     kb = KeyBindings()
     enabled = input_enabled if input_enabled is not None else Always()
 
+    def _can_move_cursor_visually_within_wrapped_line(delta_visible_y: int) -> bool:
+        """Return True when Up/Down should move within a wrapped visual line.
+
+        prompt_toolkit's default Up/Down behavior operates on logical lines
+        (split by '\n'). When a single logical line wraps across terminal
+        rows, pressing Up/Down should move within those wrapped rows instead of
+        triggering history navigation.
+
+        We only intercept when the cursor can move to an adjacent *visible*
+        line that maps to the same input line.
+        """
+
+        try:
+            app = get_app()
+            window = app.layout.current_window
+            ri = window.render_info
+            if ri is None:
+                return False
+
+            current_visible_y = int(ri.cursor_position.y)
+            target_visible_y = current_visible_y + delta_visible_y
+            if target_visible_y < 0:
+                return False
+
+            current_input_line = ri.visible_line_to_input_line.get(current_visible_y)
+            target_input_line = ri.visible_line_to_input_line.get(target_visible_y)
+            return current_input_line is not None and current_input_line == target_input_line
+        except Exception:
+            return False
+
+    def _move_cursor_visually_within_wrapped_line(event: KeyPressEvent, *, delta_visible_y: int) -> None:
+        """Move the cursor Up/Down by one wrapped screen row, keeping column."""
+
+        buf = event.current_buffer
+        try:
+            window = event.app.layout.current_window
+            ri = window.render_info
+            if ri is None:
+                return
+
+            rowcol_to_yx = getattr(ri, "_rowcol_to_yx", None)
+            x_offset = getattr(ri, "_x_offset", None)
+            y_offset = getattr(ri, "_y_offset", None)
+            if not isinstance(rowcol_to_yx, dict) or not isinstance(x_offset, int) or not isinstance(y_offset, int):
+                return
+            rowcol_to_yx_typed = cast(dict[tuple[int, int], tuple[int, int]], rowcol_to_yx)
+
+            current_visible_y = int(ri.cursor_position.y)
+            target_visible_y = current_visible_y + delta_visible_y
+            mapping = ri.visible_line_to_row_col
+            if current_visible_y not in mapping or target_visible_y not in mapping:
+                return
+
+            current_row, _ = mapping[current_visible_y]
+            target_row, _ = mapping[target_visible_y]
+
+            # Only handle wrapped rows within the same input line.
+            if current_row != target_row:
+                return
+
+            current_abs_y = y_offset + current_visible_y
+            target_abs_y = y_offset + target_visible_y
+            cursor_abs_x = x_offset + int(ri.cursor_position.x)
+
+            def _segment_start_abs_x(row: int, abs_y: int) -> int | None:
+                xs: list[int] = []
+                for (r, _col), (y, x) in rowcol_to_yx_typed.items():
+                    if r == row and y == abs_y:
+                        xs.append(x)
+                return min(xs) if xs else None
+
+            current_start_x = _segment_start_abs_x(current_row, current_abs_y)
+            target_start_x = _segment_start_abs_x(target_row, target_abs_y)
+            if current_start_x is None or target_start_x is None:
+                return
+
+            offset_in_segment_cells = max(0, cursor_abs_x - current_start_x)
+            desired_abs_x = target_start_x + offset_in_segment_cells
+
+            candidates: list[tuple[int, int]] = []
+            for (r, col), (y, x) in rowcol_to_yx_typed.items():
+                if r == target_row and y == target_abs_y:
+                    candidates.append((col, x))
+            if not candidates:
+                return
+
+            # Pick the closest column at/before the desired X. If the desired
+            # position is before the first character, snap to the first.
+            candidates.sort(key=lambda t: t[1])
+            chosen_display_col = candidates[0][0]
+            for col, x in candidates:
+                if x <= desired_abs_x:
+                    chosen_display_col = col
+                else:
+                    break
+
+            control = event.app.layout.current_control
+            get_processed_line = getattr(control, "_last_get_processed_line", None)
+            target_source_col = chosen_display_col
+            if callable(get_processed_line):
+                processed_line = get_processed_line(target_row)
+                display_to_source = getattr(processed_line, "display_to_source", None)
+                if callable(display_to_source):
+                    display_to_source_fn = cast(Callable[[int], int], display_to_source)
+                    target_source_col = display_to_source_fn(chosen_display_col)
+
+            doc = buf.document  # type: ignore[reportUnknownMemberType]
+            new_index = doc.translate_row_col_to_index(target_row, target_source_col)  # type: ignore[reportUnknownMemberType]
+            buf.cursor_position = new_index  # type: ignore[reportUnknownMemberType]
+            event.app.invalidate()  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            return
+
     def _should_submit_instead_of_accepting_completion(buf: Buffer) -> bool:
         """Return True when Enter should submit even if completions are visible.
 
@@ -174,6 +288,26 @@ def create_key_bindings(
         _cycle_completion(buf, delta=-1)
         event.app.invalidate()  # type: ignore[reportUnknownMemberType]
 
+    @kb.add(
+        "up",
+        filter=enabled
+        & ~has_completions
+        & Condition(lambda: _can_move_cursor_visually_within_wrapped_line(delta_visible_y=-1)),
+        eager=True,
+    )
+    def _(event: KeyPressEvent) -> None:
+        _move_cursor_visually_within_wrapped_line(event, delta_visible_y=-1)
+
+    @kb.add(
+        "down",
+        filter=enabled
+        & ~has_completions
+        & Condition(lambda: _can_move_cursor_visually_within_wrapped_line(delta_visible_y=1)),
+        eager=True,
+    )
+    def _(event: KeyPressEvent) -> None:
+        _move_cursor_visually_within_wrapped_line(event, delta_visible_y=1)
+
     @kb.add("c-j", filter=enabled)
     def _(event: KeyPressEvent) -> None:
         event.current_buffer.insert_text("\n")  # type: ignore

klaude_code/ui/modes/repl/renderer.py

@@ -257,7 +257,7 @@ class REPLRenderer:
             self.print(r_developer.render_developer_message(e))
 
     def display_command_output(self, e: events.DeveloperMessageEvent) -> None:
-        if not e.item.command_output:
+        if not r_developer.get_command_output(e.item):
             return
         with self.session_print_context(e.session_id):
             self.print(r_developer.render_command_output(e))
@@ -458,6 +458,7 @@ class REPLRenderer:
             return
         with contextlib.suppress(Exception):
             # Avoid cursor restore when stopping right before prompt_toolkit.
+            # This will leave a blank line before prompt input
             self._bottom_live.transient = False
             self._bottom_live.stop()
         self._bottom_live = None