klaude-code 1.2.17__py3-none-any.whl → 1.2.18__py3-none-any.whl

klaude_code/core/reminders.py

@@ -1,4 +1,3 @@
-import json
 import re
 import shlex
 from collections.abc import Awaitable, Callable
@@ -282,7 +281,6 @@ def get_memory_paths() -> list[tuple[Path, str]]:
             "user's private global instructions for all projects",
         ),
         (Path.cwd() / "AGENTS.md", "project instructions, checked into the codebase"),
-        (Path.cwd() / "AGENT.md", "project instructions, checked into the codebase"),
         (Path.cwd() / "CLAUDE.md", "project instructions, checked into the codebase"),
     ]
 
@@ -351,46 +349,22 @@ IMPORTANT: this context may or may not be relevant to your tasks. You should not
     return None
 
 
-def get_last_turn_tool_call(session: Session) -> list[model.ToolCallItem]:
-    tool_calls: list[model.ToolCallItem] = []
-    for item in reversed(session.conversation_history):
-        if isinstance(item, model.ToolCallItem):
-            tool_calls.append(item)
-        if isinstance(
-            item,
-            (
-                model.ReasoningEncryptedItem,
-                model.ReasoningTextItem,
-                model.AssistantMessageItem,
-            ),
-        ):
-            break
-    return tool_calls
-
-
 MEMORY_FILE_NAMES = ["CLAUDE.md", "AGENTS.md", "AGENT.md"]
 
 
 async def last_path_memory_reminder(
     session: Session,
 ) -> model.DeveloperMessageItem | None:
-    """When last turn tool call entered a directory (or parent directory) with CLAUDE.md AGENTS.md"""
-    tool_calls = get_last_turn_tool_call(session)
-    if len(tool_calls) == 0:
+    """Load CLAUDE.md/AGENTS.md from directories containing files in file_tracker.
+
+    Uses session.file_tracker to detect accessed paths (works for both tool calls
+    and @ file references). Uses session.loaded_memory to avoid duplicate loading.
+    """
+    if not session.file_tracker:
         return None
-    paths: list[str] = []
-    for tool_call in tool_calls:
-        if tool_call.name in (tools.READ, tools.EDIT, tools.MULTI_EDIT, tools.WRITE):
-            try:
-                json_dict = json.loads(tool_call.arguments)
-                if path := json_dict.get("file_path", ""):
-                    paths.append(path)
-            except json.JSONDecodeError:
-                continue
-    paths = list(set(paths))
+
+    paths = list(session.file_tracker.keys())
     memories: list[Memory] = []
-    if len(paths) == 0:
-        return None
 
     cwd = Path.cwd().resolve()
     loaded_set: set[str] = set(session.loaded_memory)
@@ -484,8 +458,8 @@ def load_agent_reminders(
     reminders.extend(
         [
             memory_reminder,
-            last_path_memory_reminder,
             at_file_reader_reminder,
+            last_path_memory_reminder,
             file_changed_externally_reminder,
             image_reminder,
         ]

klaude_code/core/tool/file/read_tool.py

@@ -16,12 +16,6 @@ from klaude_code.core.tool.tool_context import get_current_file_tracker
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
-SYSTEM_REMINDER_MALICIOUS = (
-    "<system-reminder>\n"
-    "Whenever you read a file, you should consider whether it looks malicious. If it does, you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer high-level questions about the code behavior.\n"
-    "</system-reminder>"
-)
-
 _IMAGE_MIME_TYPES: dict[str, str] = {
     ".png": "image/png",
     ".jpg": "image/jpeg",
@@ -51,6 +45,8 @@ class ReadSegmentResult:
     selected_lines: list[tuple[int, str]]
     selected_chars_count: int
     remaining_selected_beyond_cap: int
+    # For large file diagnostics: list of (start_line, end_line, char_count)
+    segment_char_stats: list[tuple[int, int, int]]
 
 
 def _read_segment(options: ReadOptions) -> ReadSegmentResult:
@@ -59,6 +55,13 @@ def _read_segment(options: ReadOptions) -> ReadSegmentResult:
     remaining_selected_beyond_cap = 0
     selected_lines: list[tuple[int, str]] = []
     selected_chars = 0
+
+    # Track char counts per 100-line segment for diagnostics
+    segment_size = 100
+    segment_char_stats: list[tuple[int, int, int]] = []
+    current_segment_start = options.offset
+    current_segment_chars = 0
+
     with open(options.file_path, encoding="utf-8", errors="replace") as f:
         for line_no, raw_line in enumerate(f, start=1):
             total_lines = line_no
@@ -74,16 +77,32 @@ def _read_segment(options: ReadOptions) -> ReadSegmentResult:
                     content[: options.char_limit_per_line]
                     + f" ... (more {truncated_chars} characters in this line are truncated)"
                 )
-            selected_chars += len(content) + 1
+            line_chars = len(content) + 1
+            selected_chars += line_chars
+            current_segment_chars += line_chars
+
+            # Check if we've completed a segment
+            if selected_lines_count % segment_size == 0:
+                segment_char_stats.append((current_segment_start, line_no, current_segment_chars))
+                current_segment_start = line_no + 1
+                current_segment_chars = 0
+
             if options.global_line_cap is None or len(selected_lines) < options.global_line_cap:
                 selected_lines.append((line_no, content))
             else:
                 remaining_selected_beyond_cap += 1
+
+    # Add the last partial segment if any
+    if current_segment_chars > 0 and selected_lines_count > 0:
+        last_line = options.offset + selected_lines_count - 1
+        segment_char_stats.append((current_segment_start, last_line, current_segment_chars))
+
     return ReadSegmentResult(
         total_lines=total_lines,
         selected_lines=selected_lines,
         selected_chars_count=selected_chars,
         remaining_selected_beyond_cap=remaining_selected_beyond_cap,
+        segment_char_stats=segment_char_stats,
     )
 
 
@@ -292,10 +311,21 @@ class ReadTool(ToolABC):
 
         # After limit/offset, if total selected chars exceed limit, error (only check if limits are enabled)
         if max_chars is not None and read_result.selected_chars_count > max_chars:
+            # Build segment statistics for better guidance
+            stats_lines: list[str] = []
+            for start, end, chars in read_result.segment_char_stats:
+                stats_lines.append(f"  Lines {start}-{end}: {chars} chars")
+            segment_stats_str = "\n".join(stats_lines) if stats_lines else "  (no segment data)"
+
             return model.ToolResultItem(
                 status="error",
                 output=(
-                    f"File content ({read_result.selected_chars_count} chars) exceeds maximum allowed tokens ({max_chars}). Please use offset and limit parameters to read specific portions of the file, or use the `rg` command to search for specific content."
+                    f"Selected file content {read_result.selected_chars_count} chars exceeds maximum allowed chars ({max_chars}).\n"
+                    f"File has {read_result.total_lines} total lines.\n\n"
+                    f"Character distribution by segment:\n{segment_stats_str}\n\n"
+                    f"Use offset and limit parameters to read specific portions. "
+                    f"For example: offset=1, limit=100 to read the first 100 lines. "
+                    f"Or use `rg` command to search for specific content."
                 ),
             )
 
@@ -304,8 +334,6 @@ class ReadTool(ToolABC):
         if read_result.remaining_selected_beyond_cap > 0:
             lines_out.append(f"... (more {read_result.remaining_selected_beyond_cap} lines are truncated)")
         read_result_str = "\n".join(lines_out)
-        # if read_result_str:
-        # read_result_str += "\n\n" + SYSTEM_REMINDER_MALICIOUS
 
         # Update FileTracker with last modified time
         _track_file_access(file_path)

klaude_code/core/tool/shell/bash_tool.py

@@ -11,8 +11,28 @@ 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
 
-# Regex to strip ANSI escape sequences from command output
-_ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-9;]*m")
+# Regex to strip ANSI and terminal control sequences from command output
+#
+# This is intentionally broader than just SGR color codes (e.g. "\x1b[31m").
+# Many interactive or TUI-style programs emit additional escape sequences
+# that move the cursor, clear the screen, or switch screen buffers
+# (CSI/OSC/DCS/APC/PM, etc). If these reach the Rich console, they can
+# corrupt the REPL layout. We therefore remove all of them before
+# rendering the output.
+_ANSI_ESCAPE_RE = re.compile(
+    r"""
+    \x1B
+    (?:
+        \[[0-?]*[ -/]*[@-~]         |  # CSI sequences
+        \][0-?]*.*?(?:\x07|\x1B\\) |  # OSC sequences
+        P.*?(?:\x07|\x1B\\)       |  # DCS sequences
+        _.*?(?:\x07|\x1B\\)       |  # APC sequences
+        \^.*?(?:\x07|\x1B\\)      |  # PM sequences
+        [@-Z\\-_]                      # 2-char sequences
+    )
+    """,
+    re.VERBOSE | re.DOTALL,
+)
 
 
 @register(tools.BASH)

klaude_code/core/tool/tool_runner.py

@@ -9,6 +9,9 @@ from klaude_code.core.tool.truncation import truncate_tool_output
 from klaude_code.protocol import model, tools
 from klaude_code.protocol.sub_agent import is_sub_agent_tool
 
+# Tools that can run concurrently (IO-bound, no local state mutations)
+_CONCURRENT_TOOLS: frozenset[str] = frozenset({tools.WEB_SEARCH, tools.WEB_FETCH})
+
 
 async def run_tool(tool_call: model.ToolCallItem, registry: dict[str, type[ToolABC]]) -> model.ToolResultItem:
     """Execute a tool call and return the result.
@@ -89,8 +92,8 @@ class ToolExecutor:
     """Execute and coordinate a batch of tool calls for a single turn.
 
     The executor is responsible for:
-    - Partitioning tool calls into regular tools and sub-agent tools
-    - Running regular tools sequentially and sub-agent tools concurrently
+    - Partitioning tool calls into sequential and concurrent tools
+    - Running sequential tools one by one and concurrent tools in parallel
     - Emitting ToolCall/ToolResult events and tool side-effect events
     - Tracking unfinished calls so `cancel()` can synthesize cancellation results
     """
@@ -106,7 +109,7 @@ class ToolExecutor:
 
         self._unfinished_calls: dict[str, model.ToolCallItem] = {}
         self._call_event_emitted: set[str] = set()
-        self._sub_agent_tasks: set[asyncio.Task[list[ToolExecutorEvent]]] = set()
+        self._concurrent_tasks: set[asyncio.Task[list[ToolExecutorEvent]]] = set()
 
     async def run_tools(self, tool_calls: list[model.ToolCallItem]) -> AsyncGenerator[ToolExecutorEvent]:
         """Run the given tool calls and yield execution events.
@@ -119,10 +122,10 @@ class ToolExecutor:
         for tool_call in tool_calls:
             self._unfinished_calls[tool_call.call_id] = tool_call
 
-        regular_tool_calls, sub_agent_tool_calls = self._partition_tool_calls(tool_calls)
+        sequential_tool_calls, concurrent_tool_calls = self._partition_tool_calls(tool_calls)
 
-        # Run regular tools sequentially.
-        for tool_call in regular_tool_calls:
+        # Run sequential tools one by one.
+        for tool_call in sequential_tool_calls:
             tool_call_event = self._build_tool_call_started(tool_call)
             self._call_event_emitted.add(tool_call.call_id)
             yield tool_call_event
@@ -136,16 +139,16 @@ class ToolExecutor:
             for exec_event in result_events:
                 yield exec_event
 
-        # Run sub-agent tools concurrently.
-        if sub_agent_tool_calls:
+        # Run concurrent tools (sub-agents, web tools) in parallel.
+        if concurrent_tool_calls:
             execution_tasks: list[asyncio.Task[list[ToolExecutorEvent]]] = []
-            for tool_call in sub_agent_tool_calls:
+            for tool_call in concurrent_tool_calls:
                 tool_call_event = self._build_tool_call_started(tool_call)
                 self._call_event_emitted.add(tool_call.call_id)
                 yield tool_call_event
 
                 task = asyncio.create_task(self._run_single_tool_call(tool_call))
-                self._register_sub_agent_task(task)
+                self._register_concurrent_task(task)
                 execution_tasks.append(task)
 
             for task in asyncio.as_completed(execution_tasks):
@@ -165,7 +168,7 @@ class ToolExecutor:
     def cancel(self) -> Iterable[ToolExecutorEvent]:
         """Cancel unfinished tool calls and synthesize error results.
 
-        - Cancels any running sub-agent tool tasks so they stop emitting events.
+        - Cancels any running concurrent tool tasks so they stop emitting events.
         - For each unfinished tool call, yields a ToolExecutionCallStarted (if not
           already emitted for this turn) followed by a ToolExecutionResult with
           error status and a standard cancellation output. The corresponding
@@ -174,11 +177,11 @@ class ToolExecutor:
 
         events_to_yield: list[ToolExecutorEvent] = []
 
-        # Cancel running sub-agent tool tasks.
-        for task in list(self._sub_agent_tasks):
+        # Cancel running concurrent tool tasks.
+        for task in list(self._concurrent_tasks):
             if not task.done():
                 task.cancel()
-        self._sub_agent_tasks.clear()
+        self._concurrent_tasks.clear()
 
         if not self._unfinished_calls:
             return events_to_yield
@@ -203,11 +206,11 @@ class ToolExecutor:
 
         return events_to_yield
 
-    def _register_sub_agent_task(self, task: asyncio.Task[list[ToolExecutorEvent]]) -> None:
-        self._sub_agent_tasks.add(task)
+    def _register_concurrent_task(self, task: asyncio.Task[list[ToolExecutorEvent]]) -> None:
+        self._concurrent_tasks.add(task)
 
         def _cleanup(completed: asyncio.Task[list[ToolExecutorEvent]]) -> None:
-            self._sub_agent_tasks.discard(completed)
+            self._concurrent_tasks.discard(completed)
 
         task.add_done_callback(_cleanup)
 
@@ -215,14 +218,14 @@ class ToolExecutor:
     def _partition_tool_calls(
         tool_calls: list[model.ToolCallItem],
     ) -> tuple[list[model.ToolCallItem], list[model.ToolCallItem]]:
-        regular_tool_calls: list[model.ToolCallItem] = []
-        sub_agent_tool_calls: list[model.ToolCallItem] = []
+        sequential_tool_calls: list[model.ToolCallItem] = []
+        concurrent_tool_calls: list[model.ToolCallItem] = []
         for tool_call in tool_calls:
-            if is_sub_agent_tool(tool_call.name):
-                sub_agent_tool_calls.append(tool_call)
+            if is_sub_agent_tool(tool_call.name) or tool_call.name in _CONCURRENT_TOOLS:
+                concurrent_tool_calls.append(tool_call)
             else:
-                regular_tool_calls.append(tool_call)
-        return regular_tool_calls, sub_agent_tool_calls
+                sequential_tool_calls.append(tool_call)
+        return sequential_tool_calls, concurrent_tool_calls
 
     def _build_tool_call_started(self, tool_call: model.ToolCallItem) -> ToolExecutionCallStarted:
         return ToolExecutionCallStarted(tool_call=tool_call)

klaude_code/core/tool/truncation.py

@@ -21,6 +21,15 @@ class TruncationResult:
     truncated_length: int = 0
 
 
+FILE_SAVED_PATTERN = re.compile(r"<file_saved>([^<]+)</file_saved>")
+
+
+def _extract_saved_file_path(output: str) -> str | None:
+    """Extract file path from <file_saved> tag if present."""
+    match = FILE_SAVED_PATTERN.search(output)
+    return match.group(1) if match else None
+
+
 def _extract_url_filename(url: str) -> str:
     """Extract a safe filename from a URL."""
     parsed = urlparse(url)
@@ -116,24 +125,29 @@ class SmartTruncationStrategy(TruncationStrategy):
         if original_length <= self.max_length:
             return TruncationResult(output=output, was_truncated=False, original_length=original_length)
 
-        # Save full output to file
-        saved_file_path = self._save_to_file(output, tool_call)
+        # Check if file was already saved (e.g., by WebFetch)
+        existing_file_path = _extract_saved_file_path(output)
+        saved_file_path = existing_file_path or self._save_to_file(output, tool_call)
+
+        # Strip existing <file_saved> tag to avoid duplication in head/tail
+        content_to_truncate = FILE_SAVED_PATTERN.sub("", output).lstrip("\n") if existing_file_path else output
+        content_length = len(content_to_truncate)
 
-        truncated_length = original_length - self.head_chars - self.tail_chars
-        head_content = output[: self.head_chars]
-        tail_content = output[-self.tail_chars :]
+        truncated_length = content_length - self.head_chars - self.tail_chars
+        head_content = content_to_truncate[: self.head_chars]
+        tail_content = content_to_truncate[-self.tail_chars :]
 
         # Build truncated output with file info
         if saved_file_path:
             header = (
-                f"<system-reminder>Output truncated: {truncated_length} chars hidden. "
-                f"Full tool output saved to {saved_file_path}. "
-                f"Use Read with limit+offset or rg/grep to inspect.\n"
+                f"<system-reminder>Output truncated ({truncated_length} chars hidden) to reduce context usage. "
+                f"Full content saved to <file_saved>{saved_file_path}</file_saved>. "
+                f"Use Read(offset, limit) or rg to inspect if needed. "
                 f"Showing first {self.head_chars} and last {self.tail_chars} chars:</system-reminder>\n\n"
             )
         else:
             header = (
-                f"<system-reminder>Output truncated: {truncated_length} chars hidden. "
+                f"<system-reminder>Output truncated ({truncated_length} chars hidden) to reduce context usage. "
                 f"Showing first {self.head_chars} and last {self.tail_chars} chars:</system-reminder>\n\n"
             )
 

klaude_code/core/tool/web/web_fetch_tool.md

@@ -5,4 +5,4 @@ The tool automatically processes the response based on Content-Type:
 - JSON responses are formatted with indentation
 - Markdown and other text content is returned as-is
 
-Use this tool to retrieve web page content for analysis.
+Content is always saved to a local file. The file path is included at the start of the output in a `<file_saved>` tag. For large content that gets truncated, you can read the saved file directly.

klaude_code/core/tool/web/web_fetch_tool.py

@@ -1,18 +1,23 @@
 import asyncio
 import json
+import re
+import time
 import urllib.error
 import urllib.request
 from http.client import HTTPResponse
 from pathlib import Path
+from urllib.parse import urlparse
 
 from pydantic import BaseModel
 
+from klaude_code import const
 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
 
 DEFAULT_TIMEOUT_SEC = 30
 DEFAULT_USER_AGENT = "Mozilla/5.0 (compatible; KlaudeCode/1.0)"
+WEB_FETCH_SAVE_DIR = Path(const.TOOL_OUTPUT_TRUNCATION_DIR) / "web"
 
 
 def _extract_content_type(response: HTTPResponse) -> str:
@@ -43,6 +48,30 @@ def _format_json(text: str) -> str:
         return text
 
 
+def _extract_url_filename(url: str) -> str:
+    """Extract a safe filename from a URL."""
+    parsed = urlparse(url)
+    host = parsed.netloc.replace(".", "_").replace(":", "_")
+    path = parsed.path.strip("/").replace("/", "_")
+    name = f"{host}_{path}" if path else host
+    name = re.sub(r"[^a-zA-Z0-9_\-]", "_", name)
+    return name[:80] if len(name) > 80 else name
+
+
+def _save_web_content(url: str, content: str) -> str | None:
+    """Save web content to file. Returns file path or None on failure."""
+    try:
+        WEB_FETCH_SAVE_DIR.mkdir(parents=True, exist_ok=True)
+        timestamp = int(time.time())
+        identifier = _extract_url_filename(url)
+        filename = f"{identifier}-{timestamp}.md"
+        file_path = WEB_FETCH_SAVE_DIR / filename
+        file_path.write_text(content, encoding="utf-8")
+        return str(file_path)
+    except OSError:
+        return None
+
+
 def _process_content(content_type: str, text: str) -> str:
     """Process content based on Content-Type header."""
     if content_type == "text/html":
@@ -127,9 +156,15 @@ class WebFetchTool(ToolABC):
             content_type, text = await asyncio.to_thread(_fetch_url, url)
             processed = _process_content(content_type, text)
 
+            # Always save content to file
+            saved_path = _save_web_content(url, processed)
+
+            # Build output with file path info
+            output = f"<file_saved>{saved_path}</file_saved>\n\n{processed}" if saved_path else processed
+
             return model.ToolResultItem(
                 status="success",
-                output=processed,
+                output=output,
             )
 
         except urllib.error.HTTPError as e:

klaude_code/core/turn.py

@@ -100,6 +100,8 @@ class TurnExecutor:
         self._context = context
         self._tool_executor: ToolExecutor | None = None
         self._turn_result: TurnResult | None = None
+        self._assistant_delta_buffer: list[str] = []
+        self._assistant_response_id: str | None = None
 
     @property
     def report_back_result(self) -> str | None:
@@ -138,6 +140,7 @@ class TurnExecutor:
     def cancel(self) -> list[events.Event]:
         """Cancel running tools and return any resulting events."""
         ui_events: list[events.Event] = []
+        self._persist_partial_assistant_on_cancel()
         if self._tool_executor is not None:
             for exec_event in self._tool_executor.cancel():
                 for ui_event in build_events_from_tool_executor_event(self._context.session_ctx.session_id, exec_event):
@@ -227,6 +230,9 @@ class TurnExecutor:
                         session_id=session_ctx.session_id,
                     )
                 case model.AssistantMessageDelta() as item:
+                    if item.response_id:
+                        self._assistant_response_id = item.response_id
+                    self._assistant_delta_buffer.append(item.content)
                     yield events.AssistantMessageDeltaEvent(
                         content=item.content,
                         response_id=item.response_id,
@@ -274,6 +280,8 @@ class TurnExecutor:
             session_ctx.append_history([turn_result.assistant_message])
         if turn_result.tool_calls:
             session_ctx.append_history(turn_result.tool_calls)
+        self._assistant_delta_buffer.clear()
+        self._assistant_response_id = None
 
     async def _run_tool_executor(self, tool_calls: list[model.ToolCallItem]) -> AsyncGenerator[events.Event]:
         """Run tools for the turn and translate executor events to UI events."""
@@ -292,3 +300,23 @@ class TurnExecutor:
                         yield ui_event
             finally:
                 self._tool_executor = None
+
+    def _persist_partial_assistant_on_cancel(self) -> None:
+        """Persist streamed assistant text when a turn is interrupted.
+
+        Reasoning and tool calls are intentionally discarded on interrupt; only
+        the assistant message text collected so far is saved so it appears in
+        subsequent history/context.
+        """
+
+        if not self._assistant_delta_buffer:
+            return
+        partial_text = "".join(self._assistant_delta_buffer) + "<system interrupted by user>"
+        if not partial_text:
+            return
+        message_item = model.AssistantMessageItem(
+            content=partial_text,
+            response_id=self._assistant_response_id,
+        )
+        self._context.session_ctx.append_history([message_item])
+        self._assistant_delta_buffer.clear()

klaude_code/protocol/commands.py

@@ -3,6 +3,7 @@ from enum import Enum
 
 class CommandName(str, Enum):
     INIT = "init"
+    DEBUG = "debug"
     DIFF = "diff"
     HELP = "help"
     MODEL = "model"

klaude_code/protocol/sub_agent/web.py

@@ -20,14 +20,15 @@ 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
 - Use `output_format` (JSON Schema) to get structured data back from the agent
-- 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.
 
 What you receive:
 - The agent returns a text response summarizing its findings
 - With `output_format`, you receive structured JSON matching your schema
-- The response is the agent's analysis, not raw web content\
+- The response is the agent's analysis, not raw web content
+- Web content is saved to local files (paths included in Sources) - read them directly if you need full content\
 """
 
 WEB_AGENT_PARAMETERS = {

klaude_code/session/session.py

@@ -36,7 +36,7 @@ class Session(BaseModel):
 
     @property
     def messages_count(self) -> int:
-        """Count of user and assistant messages in conversation history.
+        """Count of user, assistant messages, and tool calls in conversation history.
 
         This is a cached property that is invalidated when append_history is called.
         """
@@ -44,7 +44,7 @@ class Session(BaseModel):
             self._messages_count_cache = sum(
                 1
                 for it in self.conversation_history
-                if isinstance(it, (model.UserMessageItem, model.AssistantMessageItem))
+                if isinstance(it, (model.UserMessageItem, model.AssistantMessageItem, model.ToolCallItem))
             )
         return self._messages_count_cache
 

klaude_code/session/templates/export_session.html

@@ -9,22 +9,36 @@
       href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 24 24%22 fill=%22none%22 stroke=%22%230851b2%22 stroke-width=%222%22 stroke-linecap=%22round%22 stroke-linejoin=%22round%22><polyline points=%2216 18 22 12 16 6%22></polyline><polyline points=%228 6 2 12 8 18%22></polyline></svg>"
     />
     <link
-      href="https://cdn.jsdelivr.net/npm/@fontsource/geist-sans/latin-400.css"
+      href="https://cdn.jsdelivr.net/npm/@fontsource/source-sans-3/400.css"
       rel="stylesheet"
     />
     <link
-      href="https://cdn.jsdelivr.net/npm/@fontsource/geist-sans/latin-500.css"
+      href="https://cdn.jsdelivr.net/npm/@fontsource/source-sans-3/400-italic.css"
       rel="stylesheet"
     />
     <link
-      href="https://cdn.jsdelivr.net/npm/@fontsource/geist-sans/latin-700.css"
+      href="https://cdn.jsdelivr.net/npm/@fontsource/source-sans-3/700.css"
+      rel="stylesheet"
+    />
+    <link
+      href="https://cdn.jsdelivr.net/npm/@fontsource/source-sans-3/700-italic.css"
+      rel="stylesheet"
+    />
+    <link
+      href="https://cdn.jsdelivr.net/npm/@fontsource/fira-code/400.css"
+      rel="stylesheet"
+    />
+    <link
+      href="https://cdn.jsdelivr.net/npm/@fontsource/fira-code/700.css"
       rel="stylesheet"
     />
     <style>
       :root {
-        --bg-body: #ededed;
-        --bg-container: #f0f0f0;
-        --bg-card: #f0f0f0;
+        --bg-body: #eae9e5;
+        --bg-container: #edece9;
+        --bg-card: #efeeeb;
+        --bg-error: #ffebee;
+        --bg-code: #f2f1ed;
         --border: #c8c8c8;
         --text: #111111;
         --text-dim: #64748b;
@@ -32,13 +46,11 @@
         --accent-dim: rgba(8, 145, 178, 0.08);
         --success: #15803d;
         --error: #dc2626;
-        --bg-error: #ffebee;
-        --bg-code: #f3f3f3;
         --fg-inline-code: #4f4fc7;
-        --font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, Liberation Mono, Courier New, monospace;
-        --font-markdown-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, Liberation Mono, Courier New, monospace;
-        --font-markdown: "Geist Sans", system-ui, sans-serif;
-        --font-weight-bold: 800;
+        --font-mono: "Fira Code", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, Liberation Mono, Courier New, monospace;
+        --font-markdown-mono: "Fira Code", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, Liberation Mono, Courier New, monospace;
+        --font-markdown: "Source Sans 3", system-ui, sans-serif;
+        --font-weight-bold: 700;
         --font-size-xs: 13px;
         --font-size-sm: 14px;
         --font-size-base: 15px;
@@ -62,7 +74,6 @@
         background-color: var(--bg-body);
         color: var(--text);
         font-family: var(--font-mono);
-        font-feature-settings: "ss18";
         line-height: 1.6;
         font-size: var(--font-size-lg);
         -webkit-font-smoothing: antialiased;