klaude-code 1.5.0__tar.gz → 1.7.0__tar.gz

{klaude_code-1.5.0 → klaude_code-1.7.0}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.5.0
+Version: 1.7.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
 Requires-Dist: ddgs>=9.9.3
 Requires-Dist: diff-match-patch>=20241021
+Requires-Dist: google-genai>=1.56.0
 Requires-Dist: markdown-it-py>=4.0.0
 Requires-Dist: openai>=1.102.0
 Requires-Dist: pillow>=12.0.0
@@ -34,6 +35,10 @@ Minimal code agent CLI.
 - **Output truncation**: Large outputs saved to file system with snapshot links
 - **Skills**: Built-in + user + project Agent Skills (with implicit invocation by Skill tool or explicit invocation by typing `$`)
 - **Sessions**: Resumable with `--continue`
+- **Cost tracking**: Automatic API cost calculation and display (USD/CNY)
+- **Version update check**: Background PyPI version check with upgrade prompts
+- **Terminal title**: Shows current directory and model name
+- **Mermaid diagrams**: Interactive local HTML viewer with zoom, pan, and SVG export
 - **Extras**: Slash commands, sub-agents, image paste, terminal notifications, auto-theming
 
 ## Installation
@@ -77,6 +82,7 @@ klaude [--model <name>] [--select-model]
 - `--select-model`/`-s`: Open the interactive model selector at startup (shows all models unless `--model` is also provided).
 - `--continue`/`-c`: Resume the most recent session.
 - `--resume`/`-r`: Select a session to resume for this project.
+- `--resume-by-id <id>`: Resume a session by its ID directly.
 - `--vanilla`: Minimal mode with only basic tools (Bash, Read, Edit) and no system prompts.
 
 **Model selection behavior:**
@@ -251,12 +257,18 @@ klaude session clean-all
 
 Inside the interactive session (`klaude`), use these commands to streamline your workflow:
 
-- `/dev-doc [feature]` - Generate a comprehensive execution plan for a feature.
-- `/export` - Export last assistant message to a temp Markdown file.
-- `/init` - Bootstrap a new project structure or module.
 - `/model` - Switch the active LLM during the session.
+- `/thinking` - Configure model thinking/reasoning level.
 - `/clear` - Clear the current conversation context.
-- `/diff` - Show local git diff changes.
+- `/status` - Show session usage statistics (cost, tokens, model breakdown).
+- `/resume` - Select and resume a previous session.
+- `/fork-session` - Fork current session to a new session ID (supports interactive fork point selection).
+- `/export` - Export last assistant message to a temp Markdown file.
+- `/export-online` - Export and deploy session to surge.sh as a static webpage.
+- `/debug [filters]` - Toggle debug mode and configure debug filters.
+- `/init` - Bootstrap a new project structure or module.
+- `/dev-doc [feature]` - Generate a comprehensive execution plan for a feature.
+- `/terminal-setup` - Configure terminal for Shift+Enter support.
 - `/help` - List all available commands.
 
 
@@ -267,6 +279,8 @@ Inside the interactive session (`klaude`), use these commands to streamline your
 | `Enter`              | Submit input                                |
 | `Shift+Enter`        | Insert newline (requires `/terminal-setup`) |
 | `Ctrl+J`             | Insert newline                              |
+| `Ctrl+L`             | Open model picker overlay                   |
+| `Ctrl+T`             | Open thinking level picker overlay          |
 | `Ctrl+V`             | Paste image from clipboard                  |
 | `Left/Right`         | Move cursor (wraps across lines)            |
 | `Backspace`          | Delete character or selected text           |
@@ -290,4 +304,18 @@ echo "generate quicksort in python" | klaude exec --model gpt-5.1
 
 # Partial/ambiguous name opens the interactive selector (filtered)
 echo "generate quicksort in python" | klaude exec --model gpt
+
+# Stream all events as JSON lines (for programmatic processing)
+klaude exec "what is 2+2?" --stream-json
 ```
+
+### Sub-Agents
+
+The main agent can spawn specialized sub-agents for specific tasks:
+
+| Sub-Agent | Purpose |
+|-----------|---------|
+| **Explore** | Fast codebase exploration - find files, search code, answer questions about the codebase |
+| **Task** | Handle complex multi-step tasks autonomously |
+| **WebAgent** | Search the web, fetch pages, and analyze content |
+| **Oracle** | Advanced reasoning advisor for code reviews, architecture planning, and bug analysis |

{klaude_code-1.5.0 → klaude_code-1.7.0}/README.md

@@ -14,6 +14,10 @@ Minimal code agent CLI.
 - **Output truncation**: Large outputs saved to file system with snapshot links
 - **Skills**: Built-in + user + project Agent Skills (with implicit invocation by Skill tool or explicit invocation by typing `$`)
 - **Sessions**: Resumable with `--continue`
+- **Cost tracking**: Automatic API cost calculation and display (USD/CNY)
+- **Version update check**: Background PyPI version check with upgrade prompts
+- **Terminal title**: Shows current directory and model name
+- **Mermaid diagrams**: Interactive local HTML viewer with zoom, pan, and SVG export
 - **Extras**: Slash commands, sub-agents, image paste, terminal notifications, auto-theming
 
 ## Installation
@@ -57,6 +61,7 @@ klaude [--model <name>] [--select-model]
 - `--select-model`/`-s`: Open the interactive model selector at startup (shows all models unless `--model` is also provided).
 - `--continue`/`-c`: Resume the most recent session.
 - `--resume`/`-r`: Select a session to resume for this project.
+- `--resume-by-id <id>`: Resume a session by its ID directly.
 - `--vanilla`: Minimal mode with only basic tools (Bash, Read, Edit) and no system prompts.
 
 **Model selection behavior:**
@@ -231,12 +236,18 @@ klaude session clean-all
 
 Inside the interactive session (`klaude`), use these commands to streamline your workflow:
 
-- `/dev-doc [feature]` - Generate a comprehensive execution plan for a feature.
-- `/export` - Export last assistant message to a temp Markdown file.
-- `/init` - Bootstrap a new project structure or module.
 - `/model` - Switch the active LLM during the session.
+- `/thinking` - Configure model thinking/reasoning level.
 - `/clear` - Clear the current conversation context.
-- `/diff` - Show local git diff changes.
+- `/status` - Show session usage statistics (cost, tokens, model breakdown).
+- `/resume` - Select and resume a previous session.
+- `/fork-session` - Fork current session to a new session ID (supports interactive fork point selection).
+- `/export` - Export last assistant message to a temp Markdown file.
+- `/export-online` - Export and deploy session to surge.sh as a static webpage.
+- `/debug [filters]` - Toggle debug mode and configure debug filters.
+- `/init` - Bootstrap a new project structure or module.
+- `/dev-doc [feature]` - Generate a comprehensive execution plan for a feature.
+- `/terminal-setup` - Configure terminal for Shift+Enter support.
 - `/help` - List all available commands.
 
 
@@ -247,6 +258,8 @@ Inside the interactive session (`klaude`), use these commands to streamline your
 | `Enter`              | Submit input                                |
 | `Shift+Enter`        | Insert newline (requires `/terminal-setup`) |
 | `Ctrl+J`             | Insert newline                              |
+| `Ctrl+L`             | Open model picker overlay                   |
+| `Ctrl+T`             | Open thinking level picker overlay          |
 | `Ctrl+V`             | Paste image from clipboard                  |
 | `Left/Right`         | Move cursor (wraps across lines)            |
 | `Backspace`          | Delete character or selected text           |
@@ -270,4 +283,18 @@ echo "generate quicksort in python" | klaude exec --model gpt-5.1
 
 # Partial/ambiguous name opens the interactive selector (filtered)
 echo "generate quicksort in python" | klaude exec --model gpt
+
+# Stream all events as JSON lines (for programmatic processing)
+klaude exec "what is 2+2?" --stream-json
 ```
+
+### Sub-Agents
+
+The main agent can spawn specialized sub-agents for specific tasks:
+
+| Sub-Agent | Purpose |
+|-----------|---------|
+| **Explore** | Fast codebase exploration - find files, search code, answer questions about the codebase |
+| **Task** | Handle complex multi-step tasks autonomously |
+| **WebAgent** | Search the web, fetch pages, and analyze content |
+| **Oracle** | Advanced reasoning advisor for code reviews, architecture planning, and bug analysis |

{klaude_code-1.5.0 → klaude_code-1.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.5.0"
+version = "1.7.0"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -13,6 +13,7 @@ dependencies = [
     "chardet>=5.2.0",
     "ddgs>=9.9.3",
     "diff-match-patch>=20241021",
+    "google-genai>=1.56.0",
     "markdown-it-py>=4.0.0",
     "openai>=1.102.0",
     "pillow>=12.0.0",
@@ -33,6 +34,7 @@ module-name = "klaude_code"
 
 [dependency-groups]
 dev = [
+    "hypothesis>=6.148.8",
     "import-linter>=2.6",
     "pyright>=1.1.407",
     "pytest>=8.4.1",

{klaude_code-1.5.0 → klaude_code-1.7.0}/src/klaude_code/cli/list_model.py

@@ -6,7 +6,7 @@ from rich.table import Table
 from rich.text import Text
 
 from klaude_code.config import Config
-from klaude_code.config.config import ModelConfig, ProviderConfig
+from klaude_code.config.config import ModelConfig, ProviderConfig, parse_env_var_syntax
 from klaude_code.protocol.llm_param import LLMClientProtocol
 from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 from klaude_code.ui.rich.theme import ThemeKey, get_theme
@@ -94,6 +94,29 @@ def format_api_key_display(provider: ProviderConfig) -> Text:
         return Text("N/A")
 
 
+def format_env_var_display(value: str | None) -> Text:
+    """Format environment variable display with warning if not set."""
+    env_var, resolved = parse_env_var_syntax(value)
+
+    if env_var:
+        # Using ${ENV_VAR} syntax
+        if resolved:
+            return Text.assemble(
+                (f"${{{env_var}}} = ", "dim"),
+                (mask_api_key(resolved), ""),
+            )
+        else:
+            return Text.assemble(
+                (f"${{{env_var}}} ", ""),
+                ("(not set)", ThemeKey.CONFIG_STATUS_ERROR),
+            )
+    elif value:
+        # Plain value
+        return Text(mask_api_key(value))
+    else:
+        return Text("N/A")
+
+
 def _get_model_params_display(model: ModelConfig) -> list[Text]:
     """Get display elements for model parameters."""
     params: list[Text] = []
@@ -162,15 +185,43 @@ def display_models_and_providers(config: Config):
                 format_api_key_display(provider),
             )
 
+        # AWS Bedrock parameters
+        if provider.protocol == LLMClientProtocol.BEDROCK:
+            if provider.aws_access_key:
+                provider_info.add_row(
+                    Text("AWS Key:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                    format_env_var_display(provider.aws_access_key),
+                )
+            if provider.aws_secret_key:
+                provider_info.add_row(
+                    Text("AWS Secret:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                    format_env_var_display(provider.aws_secret_key),
+                )
+            if provider.aws_region:
+                provider_info.add_row(
+                    Text("AWS Region:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                    format_env_var_display(provider.aws_region),
+                )
+            if provider.aws_session_token:
+                provider_info.add_row(
+                    Text("AWS Token:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                    format_env_var_display(provider.aws_session_token),
+                )
+            if provider.aws_profile:
+                provider_info.add_row(
+                    Text("AWS Profile:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                    format_env_var_display(provider.aws_profile),
+                )
+
         # Check if provider has valid API key
         provider_available = not provider.is_api_key_missing()
 
         # Models table for this provider
         models_table = Table.grid(padding=(0, 1), expand=True)
         models_table.add_column(width=2, no_wrap=True)  # Status
-        models_table.add_column(overflow="fold", ratio=1)  # Name
-        models_table.add_column(overflow="fold", ratio=2)  # Model
-        models_table.add_column(overflow="fold", ratio=3)  # Params
+        models_table.add_column(overflow="fold", ratio=2)  # Name
+        models_table.add_column(overflow="fold", ratio=3)  # Model
+        models_table.add_column(overflow="fold", ratio=4)  # Params
 
         # Add header
         models_table.add_row(

{klaude_code-1.5.0 → klaude_code-1.7.0}/src/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-1.5.0 → klaude_code-1.7.0}/src/klaude_code/cli/session_cmd.py

@@ -22,8 +22,9 @@ def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) ->
     log(f"Sessions to delete ({len(sessions)}):")
     for s in sessions:
         msg_count_display = "N/A" if s.messages_count == -1 else str(s.messages_count)
-        first_msg = (s.first_user_message or "").strip().replace("\n", " ")[:50]
-        if len(s.first_user_message or "") > 50:
+        first_msg_text = s.user_messages[0] if s.user_messages else ""
+        first_msg = first_msg_text.strip().replace("\n", " ")[:50]
+        if len(first_msg_text) > 50:
             first_msg += "..."
         log(f"  {_fmt(s.updated_at)}  {msg_count_display:>3} msgs  {first_msg}")
 

klaude_code-1.7.0/src/klaude_code/command/fork_session_cmd.py

@@ -0,0 +1,260 @@
+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):
+    """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"
+
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
+    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], persist_user_input=False, persist_events=False)
+
+        # 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 ({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),
+                ),
+            ),
+        )
+        return CommandResult(events=[event], persist_user_input=False, persist_events=False)

{klaude_code-1.5.0 → klaude_code-1.7.0}/src/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