klaude-code 1.2.12__py3-none-any.whl → 1.2.14__py3-none-any.whl

klaude_code/session/session.py

@@ -261,15 +261,16 @@ class Session(BaseModel):
             return False
         if prev_item is None:
             return True
-        if isinstance(
+        return isinstance(
             prev_item,
             model.UserMessageItem | model.ToolResultItem | model.DeveloperMessageItem,
-        ):
-            return True
-        return False
+        )
 
     def get_history_item(self) -> Iterable[events.HistoryItemEvent]:
+        seen_sub_agent_sessions: set[str] = set()
         prev_item: model.ConversationItem | None = None
+        last_assistant_content: str = ""
+        yield events.TaskStartEvent(session_id=self.id, sub_agent_state=self.sub_agent_state)
         for it in self.conversation_history:
             if self.need_turn_start(prev_item, it):
                 yield events.TurnStartEvent(
@@ -278,6 +279,7 @@ class Session(BaseModel):
             match it:
                 case model.AssistantMessageItem() as am:
                     content = am.content or ""
+                    last_assistant_content = content
                     yield events.AssistantMessageEvent(
                         content=content,
                         response_id=am.response_id,
@@ -290,7 +292,6 @@ class Session(BaseModel):
                         arguments=tc.arguments,
                         response_id=tc.response_id,
                         session_id=self.id,
-                        is_replay=True,
                     )
                 case model.ToolResultItem() as tr:
                     yield events.ToolResultEvent(
@@ -300,9 +301,9 @@ class Session(BaseModel):
                         ui_extra=tr.ui_extra,
                         session_id=self.id,
                         status=tr.status,
-                        is_replay=True,
+                        task_metadata=tr.task_metadata,
                     )
-                    # TODO: Replay Sub-Agent Events
+                    yield from self._iter_sub_agent_history(tr, seen_sub_agent_sessions)
                 case model.UserMessageItem() as um:
                     yield events.UserMessageEvent(
                         content=um.content or "",
@@ -335,6 +336,35 @@ class Session(BaseModel):
                 case _:
                     continue
             prev_item = it
+        yield events.TaskFinishEvent(session_id=self.id, task_result=last_assistant_content)
+
+    def _iter_sub_agent_history(
+        self, tool_result: model.ToolResultItem, seen_sub_agent_sessions: set[str]
+    ) -> Iterable[events.HistoryItemEvent]:
+        """Replay sub-agent session history when a tool result references it.
+
+        Sub-agent tool results embed a SessionIdUIExtra containing the child session ID.
+        When present, we load that session and yield its history events so replay/export
+        can show the full sub-agent transcript instead of only the summarized tool output.
+        """
+        ui_extra = tool_result.ui_extra
+        if not isinstance(ui_extra, model.SessionIdUIExtra):
+            return
+
+        session_id = ui_extra.session_id
+        if not session_id or session_id == self.id:
+            return
+        if session_id in seen_sub_agent_sessions:
+            return
+
+        seen_sub_agent_sessions.add(session_id)
+
+        try:
+            sub_session = Session.load(session_id)
+        except Exception:
+            return
+
+        yield from sub_session.get_history_item()
 
     class SessionMetaBrief(BaseModel):
         id: str

klaude_code/session/templates/export_session.html

@@ -886,6 +886,52 @@
         color: var(--text-dim);
       }
 
+      /* Sub-agent Session */
+      details.sub-agent-session {
+        background: transparent;
+        margin: 16px 0;
+        border-left: 3px solid var(--accent);
+        padding-left: 16px;
+      }
+      details.sub-agent-session > summary {
+        padding: 4px 0;
+        font-family: var(--font-mono);
+        font-size: var(--font-size-sm);
+        text-transform: uppercase;
+        font-weight: var(--font-weight-bold);
+        cursor: pointer;
+        user-select: none;
+        list-style: none;
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        min-height: 24px;
+        line-height: 1.2;
+        color: var(--text-dim);
+        transition: color 0.2s;
+      }
+      details.sub-agent-session > summary:hover,
+      details.sub-agent-session[open] > summary {
+        color: var(--text);
+      }
+      details.sub-agent-session > summary::-webkit-details-marker {
+        display: none;
+      }
+      details.sub-agent-session > summary::before {
+        content: "[+]";
+        color: var(--accent);
+        font-family: var(--font-mono);
+        margin-right: 4px;
+        display: inline-block;
+        min-width: 24px;
+      }
+      details.sub-agent-session[open] > summary::before {
+        content: "[-]";
+      }
+      details.sub-agent-session > .sub-agent-content {
+        padding: 8px 0 0 0;
+      }
+
       /* Scroll to Bottom Button */
       .scroll-btn {
         position: fixed;

klaude_code/trace/__init__.py

@@ -1,3 +1,3 @@
-from .log import DebugType, is_debug_enabled, log, log_debug, logger, set_debug_logging
+from .log import DebugType, is_debug_enabled, log, log_debug, logger, prepare_debug_log_file, set_debug_logging
 
-__all__ = ["log", "log_debug", "logger", "set_debug_logging", "DebugType", "is_debug_enabled"]
+__all__ = ["DebugType", "is_debug_enabled", "log", "log_debug", "logger", "prepare_debug_log_file", "set_debug_logging"]

klaude_code/trace/log.py

@@ -1,7 +1,13 @@
+import gzip
 import logging
+import os
+import shutil
+import subprocess
+from collections.abc import Iterable
+from datetime import datetime, timedelta
 from enum import Enum
 from logging.handlers import RotatingFileHandler
-from typing import Iterable
+from pathlib import Path
 
 from rich.console import Console
 from rich.logging import RichHandler
@@ -49,6 +55,26 @@ _file_handler: RotatingFileHandler | None = None
 _console_handler: RichHandler | None = None
 _debug_filter: DebugTypeFilter | None = None
 _debug_enabled = False
+_current_log_file: Path | None = None
+
+LOG_RETENTION_DAYS = 3
+LOG_MAX_TOTAL_BYTES = 200 * 1024 * 1024
+
+
+class GzipRotatingFileHandler(RotatingFileHandler):
+    """Rotating file handler that gzips rolled files."""
+
+    def rotation_filename(self, default_name: str) -> str:
+        """Append .gz to rotation targets."""
+
+        return f"{default_name}.gz"
+
+    def rotate(self, source: str, dest: str) -> None:
+        """Compress the rotated file and remove the original."""
+
+        with open(source, "rb") as source_file, gzip.open(dest, "wb") as dest_file:
+            shutil.copyfileobj(source_file, dest_file)
+        Path(source).unlink(missing_ok=True)
 
 
 def set_debug_logging(
@@ -66,7 +92,7 @@ def set_debug_logging(
         log_file: Path to the log file (default: debug.log)
         filters: Set of DebugType to include; None means all types
     """
-    global _file_handler, _console_handler, _debug_filter, _debug_enabled
+    global _file_handler, _console_handler, _debug_filter, _debug_enabled, _current_log_file
 
     _debug_enabled = enabled
 
@@ -80,6 +106,7 @@ def set_debug_logging(
         _console_handler = None
 
     if not enabled:
+        _current_log_file = None
         return
 
     # Create filter
@@ -87,10 +114,19 @@ def set_debug_logging(
 
     # Determine output mode
     use_file = write_to_file if write_to_file is not None else True
-    file_path = log_file if log_file is not None else const.DEFAULT_DEBUG_LOG_FILE
-
     if use_file:
-        _file_handler = RotatingFileHandler(
+        if _current_log_file is None:
+            _current_log_file = _resolve_log_file(log_file)
+        file_path = _current_log_file
+    else:
+        _current_log_file = None
+        file_path = None
+
+    if use_file and file_path is not None:
+        _prune_old_logs(const.DEFAULT_DEBUG_LOG_DIR, LOG_RETENTION_DAYS, LOG_MAX_TOTAL_BYTES)
+
+    if use_file and file_path is not None:
+        _file_handler = GzipRotatingFileHandler(
             file_path,
             maxBytes=const.LOG_MAX_BYTES,
             backupCount=const.LOG_BACKUP_COUNT,
@@ -166,3 +202,106 @@ def _build_message(objects: Iterable[str | tuple[str, str]]) -> str:
 def is_debug_enabled() -> bool:
     """Check if debug logging is currently enabled."""
     return _debug_enabled
+
+
+def prepare_debug_log_file(log_file: str | os.PathLike[str] | None = None) -> Path:
+    """Prepare and remember the log file path for this session."""
+
+    global _current_log_file
+    _current_log_file = _resolve_log_file(log_file)
+    return _current_log_file
+
+
+def get_current_log_file() -> Path | None:
+    """Return the currently active log file path, if any."""
+
+    return _current_log_file
+
+
+def _resolve_log_file(log_file: str | os.PathLike[str] | None) -> Path:
+    """Resolve the log file path and ensure directories exist."""
+
+    if log_file:
+        path = Path(log_file).expanduser()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        return path
+    else:
+        path = _build_default_log_file_path()
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.touch(exist_ok=True)
+    _refresh_latest_symlink(path)
+    return path
+
+
+def _build_default_log_file_path() -> Path:
+    """Build a per-session log path under the default log directory."""
+
+    now = datetime.now()
+    session_dir = const.DEFAULT_DEBUG_LOG_DIR / now.strftime("%Y-%m-%d")
+    session_dir.mkdir(parents=True, exist_ok=True)
+    filename = f"{now.strftime('%H%M%S')}-{os.getpid()}.log"
+    return session_dir / filename
+
+
+def _refresh_latest_symlink(target: Path) -> None:
+    """Point the debug.log symlink at the latest session file."""
+
+    latest = const.DEFAULT_DEBUG_LOG_FILE
+    try:
+        latest.unlink(missing_ok=True)
+        latest.symlink_to(target)
+    except OSError:
+        # Non-blocking best-effort; logging should still proceed
+        return
+
+
+def _prune_old_logs(log_root: Path, keep_days: int, max_total_bytes: int) -> None:
+    """Remove logs older than keep_days or when exceeding max_total_bytes."""
+
+    if not log_root.exists():
+        return
+
+    cutoff = datetime.now() - timedelta(days=keep_days)
+    files: list[Path] = [p for p in log_root.rglob("*") if p.is_file() and not p.is_symlink()]
+
+    # Remove by age
+    for path in files:
+        try:
+            mtime = datetime.fromtimestamp(path.stat().st_mtime)
+        except OSError:
+            continue
+        if mtime < cutoff:
+            _trash_path(path)
+
+    # Recompute remaining files and sizes
+    remaining: list[tuple[Path, float, int]] = []
+    total_size = 0
+    for path in log_root.rglob("*"):
+        if not path.is_file() or path.is_symlink():
+            continue
+        try:
+            stat = path.stat()
+        except OSError:
+            continue
+        remaining.append((path, stat.st_mtime, stat.st_size))
+        total_size += stat.st_size
+
+    if total_size <= max_total_bytes:
+        return
+
+    remaining.sort(key=lambda item: item[1])
+    for path, _, size in remaining:
+        _trash_path(path)
+        total_size -= size
+        if total_size <= max_total_bytes:
+            break
+
+
+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)
+    except FileNotFoundError:
+        path.unlink(missing_ok=True)

klaude_code/ui/__init__.py

@@ -73,19 +73,14 @@ def create_exec_display(debug: bool = False, stream_json: bool = False) -> Displ
 
 
 __all__ = [
-    # Abstract interfaces
+    "DebugEventDisplay",
     "DisplayABC",
+    "ExecDisplay",
     "InputProviderABC",
-    # Display mode implementations
+    "PromptToolkitInput",
     "REPLDisplay",
-    "ExecDisplay",
     "StreamJsonDisplay",
-    "DebugEventDisplay",
-    # Input implementations
-    "PromptToolkitInput",
-    # Factory functions
+    "TerminalNotifier",
     "create_default_display",
     "create_exec_display",
-    # Supporting types
-    "TerminalNotifier",
 ]

klaude_code/ui/core/stage_manager.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Awaitable, Callable
 from enum import Enum
-from typing import Awaitable, Callable
 
 
 class Stage(Enum):
@@ -19,10 +19,12 @@ class StageManager:
         self,
         *,
         finish_assistant: Callable[[], Awaitable[None]],
+        finish_thinking: Callable[[], Awaitable[None]],
         on_enter_thinking: Callable[[], None],
     ):
         self._stage = Stage.WAITING
         self._finish_assistant = finish_assistant
+        self._finish_thinking = finish_thinking
         self._on_enter_thinking = on_enter_thinking
 
     @property
@@ -49,7 +51,8 @@ class StageManager:
         self._stage = Stage.WAITING
 
     async def _leave_current_stage(self) -> None:
-        if self._stage == Stage.ASSISTANT:
+        if self._stage == Stage.THINKING:
+            await self._finish_thinking()
+        elif self._stage == Stage.ASSISTANT:
             await self.finish_assistant()
-        elif self._stage != Stage.WAITING:
-            self._stage = Stage.WAITING
+        self._stage = Stage.WAITING

klaude_code/ui/modes/debug/display.py

@@ -1,3 +1,4 @@
+import os
 from typing import override
 
 from klaude_code import const
@@ -10,7 +11,7 @@ class DebugEventDisplay(DisplayABC):
     def __init__(
         self,
         wrapped_display: DisplayABC | None = None,
-        log_file: str = const.DEFAULT_DEBUG_LOG_FILE,
+        log_file: str | os.PathLike[str] = const.DEFAULT_DEBUG_LOG_FILE,
     ):
         self.wrapped_display = wrapped_display
         self.log_file = log_file

klaude_code/ui/modes/repl/__init__.py

@@ -9,7 +9,7 @@ if TYPE_CHECKING:
     from klaude_code.core.agent import Agent
 
 
-def build_repl_status_snapshot(agent: "Agent | None", update_message: str | None) -> REPLStatusSnapshot:
+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

klaude_code/ui/modes/repl/completers.py

@@ -67,12 +67,12 @@ class _SlashCommandCompleter(Completer):
     ) -> Iterable[Completion]:
         # Only complete on first line
         if document.cursor_position_row != 0:
-            return iter([])
+            return
 
         text_before = document.current_line_before_cursor
         m = self._SLASH_TOKEN_RE.search(text_before)
         if not m:
-            return iter([])
+            return
 
         frag = m.group("frag")
         token_start = len(text_before) - len(f"/{frag}")
@@ -89,7 +89,7 @@ class _SlashCommandCompleter(Completer):
                 matched.append((cmd_name, cmd_obj, hint))
 
         if not matched:
-            return iter([])
+            return
 
         # Calculate max width for alignment
         # Find the longest command+hint length
@@ -133,10 +133,9 @@ class _ComboCompleter(Completer):
         complete_event,  # type: ignore[override]
     ) -> Iterable[Completion]:
         # Try slash command completion first (only on first line)
-        if document.cursor_position_row == 0:
-            if self._slash_completer.is_slash_command_context(document):
-                yield from self._slash_completer.get_completions(document, complete_event)
-                return
+        if document.cursor_position_row == 0 and self._slash_completer.is_slash_command_context(document):
+            yield from self._slash_completer.get_completions(document, complete_event)
+            return
 
         # Fall back to @ file completion
         yield from self._at_completer.get_completions(document, complete_event)

klaude_code/ui/modes/repl/display.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 from typing import override
 
 from klaude_code.protocol import events
@@ -53,8 +54,6 @@ class REPLDisplay(DisplayABC):
     async def stop(self) -> None:
         await self.event_handler.stop()
         # Ensure any active spinner is stopped so Rich restores the cursor.
-        try:
+        # Spinner may already be stopped or not started; ignore.
+        with contextlib.suppress(Exception):
             self.renderer.spinner_stop()
-        except Exception:
-            # Spinner may already be stopped or not started; ignore.
-            pass

klaude_code/ui/modes/repl/event_handler.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from typing import Awaitable, Callable
 
 from rich.text import Text
 
@@ -10,6 +10,7 @@ from klaude_code.protocol import events
 from klaude_code.ui.core.stage_manager import Stage, StageManager
 from klaude_code.ui.modes.repl.renderer import REPLRenderer
 from klaude_code.ui.rich.markdown import MarkdownStream
+from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.terminal.notifier import Notification, NotificationType, TerminalNotifier
 from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
 from klaude_code.ui.utils.debouncer import Debouncer
@@ -41,7 +42,7 @@ class StreamState:
     This design ensures buffer and mdstream are always in sync.
     """
 
-    def __init__(self, interval: float, flush_handler: Callable[["StreamState"], Awaitable[None]]):
+    def __init__(self, interval: float, flush_handler: Callable[[StreamState], Awaitable[None]]):
         self._active: ActiveStream | None = None
         self._flush_handler = flush_handler
         self.debouncer = Debouncer(interval=interval, callback=self._debounced_flush)
@@ -199,10 +200,14 @@ class DisplayEventHandler:
         self.assistant_stream = StreamState(
             interval=1 / const.UI_REFRESH_RATE_FPS, flush_handler=self._flush_assistant_buffer
         )
+        self.thinking_stream = StreamState(
+            interval=1 / const.UI_REFRESH_RATE_FPS, flush_handler=self._flush_thinking_buffer
+        )
         self.spinner_status = SpinnerStatusState()
 
         self.stage_manager = StageManager(
             finish_assistant=self._finish_assistant_stream,
+            finish_thinking=self._finish_thinking_stream,
             on_enter_thinking=self._print_thinking_prefix,
         )
 
@@ -222,6 +227,8 @@ class DisplayEventHandler:
                 self._on_turn_start(e)
             case events.ThinkingEvent() as e:
                 await self._on_thinking(e)
+            case events.ThinkingDeltaEvent() as e:
+                await self._on_thinking_delta(e)
             case events.AssistantMessageDeltaEvent() as e:
                 await self._on_assistant_delta(e)
             case events.AssistantMessageEvent() as e:
@@ -252,6 +259,8 @@ class DisplayEventHandler:
     async def stop(self) -> None:
         await self.assistant_stream.debouncer.flush()
         self.assistant_stream.debouncer.cancel()
+        await self.thinking_stream.debouncer.flush()
+        self.thinking_stream.debouncer.cancel()
 
     # ─────────────────────────────────────────────────────────────────────────────
     # Private event handlers
@@ -285,8 +294,41 @@ class DisplayEventHandler:
     async def _on_thinking(self, event: events.ThinkingEvent) -> None:
         if self.renderer.is_sub_agent_session(event.session_id):
             return
+        # If streaming was active, finalize it
+        if self.thinking_stream.is_active:
+            await self._finish_thinking_stream()
+        else:
+            # Non-streaming path (history replay or models without delta support)
+            await self.stage_manager.enter_thinking_stage()
+            self.renderer.display_thinking(event.content)
+
+    async def _on_thinking_delta(self, event: events.ThinkingDeltaEvent) -> None:
+        if self.renderer.is_sub_agent_session(event.session_id):
+            return
+
+        first_delta = not self.thinking_stream.is_active
+        if first_delta:
+            self.renderer.console.push_theme(self.renderer.themes.thinking_markdown_theme)
+            mdstream = MarkdownStream(
+                mdargs={
+                    "code_theme": self.renderer.themes.code_theme,
+                    "style": self.renderer.console.get_style(ThemeKey.THINKING),
+                },
+                theme=self.renderer.themes.thinking_markdown_theme,
+                console=self.renderer.console,
+                spinner=self.renderer.spinner_renderable(),
+                indent=2,
+            )
+            self.thinking_stream.start(mdstream)
+            self.renderer.spinner_stop()
+
+        self.thinking_stream.append(event.content)
+
+        if first_delta and self.thinking_stream.mdstream is not None:
+            self.thinking_stream.mdstream.update(self.thinking_stream.buffer)
+
         await self.stage_manager.enter_thinking_stage()
-        self.renderer.display_thinking(event.content)
+        self.thinking_stream.debouncer.schedule()
 
     async def _on_assistant_delta(self, event: events.AssistantMessageDeltaEvent) -> None:
         if self.renderer.is_sub_agent_session(event.session_id):
@@ -419,6 +461,22 @@ class DisplayEventHandler:
             assert mdstream is not None
             mdstream.update(state.buffer)
 
+    async def _flush_thinking_buffer(self, state: StreamState) -> None:
+        if state.is_active:
+            mdstream = state.mdstream
+            assert mdstream is not None
+            mdstream.update(state.buffer)
+
+    async def _finish_thinking_stream(self) -> None:
+        if self.thinking_stream.is_active:
+            self.thinking_stream.debouncer.cancel()
+            mdstream = self.thinking_stream.mdstream
+            assert mdstream is not None
+            mdstream.update(self.thinking_stream.buffer, final=True)
+            self.thinking_stream.finish()
+            self.renderer.console.pop_theme()
+            self.renderer.spinner_start()
+
     def _maybe_notify_task_finish(self, event: events.TaskFinishEvent) -> None:
         if self.notifier is None:
             return
@@ -453,10 +511,10 @@ class DisplayEventHandler:
                 if len(todo.content) > 0:
                     status_text = todo.content
         status_text = status_text.replace("\n", "")
-        return self._truncate_status_text(status_text, max_length=100)
+        return self._truncate_status_text(status_text, max_length=50)
 
     def _truncate_status_text(self, text: str, max_length: int) -> str:
         if len(text) <= max_length:
             return text
         truncated = text[:max_length]
-        return truncated + "..."
+        return truncated + "…"

klaude_code/ui/modes/repl/key_bindings.py

@@ -6,6 +6,7 @@ with dependencies injected to avoid circular imports.
 
 from __future__ import annotations
 
+import contextlib
 import re
 from collections.abc import Callable
 from typing import cast
@@ -35,10 +36,8 @@ def create_key_bindings(
         """Paste image from clipboard as [Image #N]."""
         tag = capture_clipboard_tag()
         if tag:
-            try:
+            with contextlib.suppress(Exception):
                 event.current_buffer.insert_text(tag)  # pyright: ignore[reportUnknownMemberType]
-            except Exception:
-                pass
 
     @kb.add("enter")
     def _(event):  # type: ignore