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

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/file/edit_tool.py

@@ -88,7 +88,7 @@ class EditTool(ToolABC):
     async def call(cls, arguments: str) -> model.ToolResultItem:
         try:
             args = EditTool.EditArguments.model_validate_json(arguments)
-        except Exception as e:  # pragma: no cover - defensive
+        except ValueError as e:  # pragma: no cover - defensive
             return model.ToolResultItem(status="error", output=f"Invalid arguments: {e}")
 
         file_path = os.path.abspath(args.file_path)
@@ -150,7 +150,7 @@ class EditTool(ToolABC):
                 # Backward-compat: old sessions only stored mtime.
                 try:
                     current_mtime = Path(file_path).stat().st_mtime
-                except Exception:
+                except OSError:
                     current_mtime = tracked_status.mtime
                 if current_mtime != tracked_status.mtime:
                     return model.ToolResultItem(
@@ -188,7 +188,7 @@ class EditTool(ToolABC):
         # Write back
         try:
             await asyncio.to_thread(write_text, file_path, after)
-        except Exception as e:  # pragma: no cover
+        except (OSError, UnicodeError) as e:  # pragma: no cover
             return model.ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
 
         # Prepare UI extra: unified diff with 3 context lines
@@ -233,7 +233,7 @@ class EditTool(ToolABC):
                     plus_range = plus.split(" ")[0]
                     start = int(plus_range.split(",")[0]) if "," in plus_range else int(plus_range)
                     after_line_no = start - 1
-                except Exception:
+                except (ValueError, IndexError):
                     after_line_no = 0
                 continue
             if line.startswith(" ") or (line.startswith("+") and not line.startswith("+++ ")):

klaude_code/core/tool/file/write_tool.py

@@ -49,7 +49,7 @@ class WriteTool(ToolABC):
     async def call(cls, arguments: str) -> model.ToolResultItem:
         try:
             args = WriteArguments.model_validate_json(arguments)
-        except Exception as e:  # pragma: no cover - defensive
+        except ValueError as e:  # pragma: no cover - defensive
             return model.ToolResultItem(status="error", output=f"Invalid arguments: {e}")
 
         file_path = os.path.abspath(args.file_path)
@@ -79,7 +79,7 @@ class WriteTool(ToolABC):
             try:
                 before = await asyncio.to_thread(read_text, file_path)
                 before_read_ok = True
-            except Exception:
+            except OSError:
                 before = ""
                 before_read_ok = False
 
@@ -98,7 +98,7 @@ class WriteTool(ToolABC):
                 # Backward-compat: old sessions only stored mtime, or we couldn't hash.
                 try:
                     current_mtime = Path(file_path).stat().st_mtime
-                except Exception:
+                except OSError:
                     current_mtime = tracked_status.mtime
                 if current_mtime != tracked_status.mtime:
                     return model.ToolResultItem(
@@ -111,7 +111,7 @@ class WriteTool(ToolABC):
 
         try:
             await asyncio.to_thread(write_text, file_path, args.content)
-        except Exception as e:  # pragma: no cover
+        except (OSError, UnicodeError) as e:  # pragma: no cover
             return model.ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
 
         if file_tracker is not None:

klaude_code/core/tool/shell/bash_tool.py

@@ -274,7 +274,7 @@ class BashTool(ToolABC):
                     proc.terminate()
             except ProcessLookupError:
                 return
-            except Exception:
+            except OSError:
                 # Fall back to kill below.
                 pass
 
@@ -356,7 +356,7 @@ class BashTool(ToolABC):
         except asyncio.CancelledError:
             # Propagate cooperative cancellation so outer layers can handle interrupts correctly.
             raise
-        except Exception as e:  # safeguard against unexpected failures
+        except OSError as e:  # safeguard: catch remaining OS-level errors (permissions, resources, etc.)
             return model.ToolResultItem(
                 status="error",
                 output=f"Execution error: {e}",

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/stream.py

@@ -20,6 +20,7 @@ from typing import Any, Literal, cast
 import httpx
 import openai
 import openai.types
+import pydantic
 from openai import AsyncStream
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 
@@ -204,7 +205,7 @@ async def parse_chat_completions_stream(
                 try:
                     usage = openai.types.CompletionUsage.model_validate(choice_usage)
                     metadata_tracker.set_usage(convert_usage(usage, param.context_limit, param.max_tokens))
-                except Exception:
+                except pydantic.ValidationError:
                     pass
 
             delta = cast(Any, getattr(choice0, "delta", None))

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)
@@ -702,7 +747,7 @@ def _render_sub_agent_session(
 
     try:
         sub_session = Session.load(session_id)
-    except Exception:
+    except (OSError, json.JSONDecodeError, ValueError):
         return None
 
     sub_history = sub_session.conversation_history

klaude_code/session/selector.py

@@ -23,7 +23,7 @@ def resume_select_session() -> str | None:
     def _fmt(ts: float) -> str:
         try:
             return time.strftime("%m-%d %H:%M:%S", time.localtime(ts))
-        except Exception:
+        except (ValueError, OSError):
             return str(ts)
 
     try:
@@ -76,6 +76,6 @@ def resume_select_session() -> str | None:
             idx = int(raw)
             if 1 <= idx <= len(sessions):
                 return str(sessions[idx - 1].id)
-        except Exception:
+        except (ValueError, EOFError):
             return None
     return None

klaude_code/session/session.py

@@ -7,7 +7,7 @@ from collections.abc import Iterable, Sequence
 from pathlib import Path
 from typing import Any, cast
 
-from pydantic import BaseModel, Field, PrivateAttr
+from pydantic import BaseModel, Field, PrivateAttr, ValidationError
 
 from klaude_code.protocol import events, llm_param, model, tools
 from klaude_code.session.store import JsonlSessionStore, ProjectPaths, build_meta_snapshot
@@ -124,7 +124,7 @@ class Session(BaseModel):
                 if isinstance(k, str) and isinstance(v, dict):
                     try:
                         file_tracker[k] = model.FileStatus.model_validate(v)
-                    except Exception:
+                    except ValidationError:
                         continue
 
         todos_raw = raw.get("todos")
@@ -135,7 +135,7 @@ class Session(BaseModel):
                     continue
                 try:
                     todos.append(model.TodoItem.model_validate(todo_raw))
-                except Exception:
+                except ValidationError:
                     continue
 
         created_at = float(raw.get("created_at", time.time()))
@@ -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)
 
@@ -306,7 +328,7 @@ class Session(BaseModel):
         seen_sub_agent_sessions.add(session_id)
         try:
             sub_session = Session.load(session_id)
-        except Exception:
+        except (OSError, json.JSONDecodeError, ValueError):
             return
         yield from sub_session.get_history_item()
 

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)