klaude-code 1.2.27__tar.gz → 1.2.29__tar.gz

{klaude_code-1.2.27 → klaude_code-1.2.29}/PKG-INFO

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

{klaude_code-1.2.27 → klaude_code-1.2.29}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.27"
+version = "1.2.29"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -27,6 +27,7 @@ dependencies = [
 
 [project.scripts]
 klaude = "klaude_code.cli.main:app"
+klaude-code = "klaude_code.cli.main:app"
 
 [tool.uv.build-backend]
 module-name = "klaude_code"

{klaude_code-1.2.27 → klaude_code-1.2.29}/src/klaude_code/cli/config_cmd.py

@@ -6,7 +6,7 @@ import sys
 
 import typer
 
-from klaude_code.config import config_path, load_config
+from klaude_code.config import config_path, create_example_config, example_config_path, load_config
 from klaude_code.trace import log
 
 
@@ -57,17 +57,24 @@ def edit_config() -> None:
         else:  # Linux and other Unix systems
             editor = "xdg-open"
 
-    # Ensure config file exists
-    load_config()
+    # Ensure config directory exists and create example config if needed
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    if create_example_config():
+        log(f"Created example config: {example_config_path}", style="dim")
+
+    # Decide which file to open
+    target_path = config_path if config_path.exists() else example_config_path
+    if target_path == example_config_path:
+        log(f"Opening example config (copy to {config_path.name} to use)", style="yellow")
 
     try:
         if editor == "open -a TextEdit":
-            subprocess.run(["open", "-a", "TextEdit", str(config_path)], check=True)
+            subprocess.run(["open", "-a", "TextEdit", str(target_path)], check=True)
         elif editor in ["open", "xdg-open"]:
             # For open/xdg-open, we need to pass the file directly
-            subprocess.run([editor, str(config_path)], check=True)
+            subprocess.run([editor, str(target_path)], check=True)
         else:
-            subprocess.run([editor, str(config_path)], check=True)
+            subprocess.run([editor, str(target_path)], check=True)
     except subprocess.CalledProcessError as e:
         log((f"Error: Failed to open editor: {e}", "red"))
         raise typer.Exit(1) from None

{klaude_code-1.2.27 → klaude_code-1.2.29}/src/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-1.2.27 → klaude_code-1.2.29}/src/klaude_code/cli/list_model.py

@@ -218,7 +218,7 @@ def display_models_and_providers(config: Config):
 
         panel = Panel(
             panel_content,
-            title=Text(f"Provider: {provider.provider_name}", style="white bold"),
+            title=Text(f"Provider: {provider.provider_name}", style=ThemeKey.CONFIG_PROVIDER),
             border_style=ThemeKey.CONFIG_PANEL_BORDER,
             padding=(0, 1),
             title_align="left",

{klaude_code-1.2.27 → klaude_code-1.2.29}/src/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-1.2.27 → klaude_code-1.2.29}/src/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-1.2.27 → klaude_code-1.2.29}/src/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-1.2.27 → klaude_code-1.2.29}/src/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-1.2.29/src/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-1.2.29/src/klaude_code/config/__init__.py

@@ -0,0 +1,19 @@
+from .config import (
+    Config,
+    UserConfig,
+    config_path,
+    create_example_config,
+    example_config_path,
+    load_config,
+    print_no_available_models_hint,
+)
+
+__all__ = [
+    "Config",
+    "UserConfig",
+    "config_path",
+    "create_example_config",
+    "example_config_path",
+    "load_config",
+    "print_no_available_models_hint",
+]

{klaude_code-1.2.27 → klaude_code-1.2.29}/src/klaude_code/config/config.py

@@ -51,6 +51,7 @@ def resolve_api_key(value: str | None) -> str | None:
 
 
 config_path = Path.home() / ".klaude" / "klaude-config.yaml"
+example_config_path = Path.home() / ".klaude" / "klaude-config.example.yaml"
 
 
 class ModelConfig(BaseModel):
@@ -227,8 +228,8 @@ class Config(BaseModel):
 def get_example_config() -> UserConfig:
     """Generate example config for user reference (will be commented out)."""
     return UserConfig(
-        main_model="my-model",
-        sub_agent_models={"explore": "fast-model", "oracle": "smart-model", "webagent": "fast-model", "task": "opus"},
+        main_model="opus",
+        sub_agent_models={"explore": "haiku", "oracle": "gpt-5.2", "webagent": "sonnet", "task": "sonnet"},
         provider_list=[
             UserProviderConfig(
                 provider_name="my-provider",
@@ -357,30 +358,32 @@ def _load_user_config() -> UserConfig | None:
         raise ValueError(f"Invalid config file: {config_path}") from e
 
 
-def _ensure_config_file_exists() -> None:
-    """Ensure config file exists with commented example."""
-    if config_path.exists():
-        return
+def create_example_config() -> bool:
+    """Create example config file if it doesn't exist.
+
+    Returns:
+        True if file was created, False if it already exists.
+    """
+    if example_config_path.exists():
+        return False
 
     example_config = get_example_config()
-    config_path.parent.mkdir(parents=True, exist_ok=True)
+    example_config_path.parent.mkdir(parents=True, exist_ok=True)
     config_dict = example_config.model_dump(mode="json", exclude_none=True)
 
-    # Comment out all example config lines
     yaml_str = yaml.dump(config_dict, default_flow_style=False, sort_keys=False) or ""
-    commented_yaml = "# Custom configuration (optional)\n"
-    commented_yaml += "# Built-in providers (anthropic, openai, openrouter, deepseek) are available automatically.\n"
-    commented_yaml += "# Just set the corresponding API key environment variable to use them.\n"
-    commented_yaml += "#\n"
-    commented_yaml += "# Example custom provider:\n"
-    commented_yaml += "\n".join(f"# {line}" if line.strip() else "#" for line in yaml_str.splitlines())
-    _ = config_path.write_text(commented_yaml)
+    header = "# Example configuration for klaude-code\n"
+    header += "# Copy this file to klaude-config.yaml and modify as needed.\n"
+    header += "# Run `klaude list` to see available models.\n"
+    header += "#\n"
+    header += "# Built-in providers (anthropic, openai, openrouter, deepseek) are available automatically.\n"
+    header += "# Just set the corresponding API key environment variable to use them.\n\n"
+    _ = example_config_path.write_text(header + yaml_str)
+    return True
 
 
 def _load_config_uncached() -> Config:
     """Load and merge builtin + user config. Always returns a valid Config."""
-    _ensure_config_file_exists()
-
     builtin_config = _get_builtin_config()
     user_config = _load_user_config()
 
@@ -417,6 +420,7 @@ def print_no_available_models_hint() -> None:
             log(f"  export {env_var}=<your-api-key>", style="dim")
     log("")
     log(f"Or add custom providers in: {config_path}", style="dim")
+    log(f"See example config: {example_config_path}", style="dim")
 
 
 # Expose cache control for tests and callers that need to invalidate the cache.

{klaude_code-1.2.27 → klaude_code-1.2.29}/src/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-1.2.27 → klaude_code-1.2.29}/src/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-1.2.27 → klaude_code-1.2.29}/src/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-1.2.27 → klaude_code-1.2.29}/src/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-1.2.27 → klaude_code-1.2.29}/src/klaude_code/core/tool/web/mermaid_tool.py

@@ -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",
                     },
                 },
@@ -49,7 +49,7 @@ class MermaidTool(ToolABC):
 
         link = cls._build_link(args.code)
         line_count = cls._count_lines(args.code)
-        ui_extra = model.MermaidLinkUIExtra(link=link, line_count=line_count)
+        ui_extra = model.MermaidLinkUIExtra(code=args.code, link=link, line_count=line_count)
         output = f"Mermaid diagram rendered successfully ({line_count} lines)."
         return model.ToolResultItem(status="success", output=output, ui_extra=ui_extra)
 

{klaude_code-1.2.27 → klaude_code-1.2.29}/src/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-1.2.27 → klaude_code-1.2.29}/src/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-1.2.27 → klaude_code-1.2.29}/src/klaude_code/protocol/model.py

@@ -127,6 +127,7 @@ class SessionIdUIExtra(BaseModel):
 
 class MermaidLinkUIExtra(BaseModel):
     type: Literal["mermaid_link"] = "mermaid_link"
+    code: str = ""
     link: str
     line_count: int
 
@@ -260,6 +261,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