klaude-code 2.8.1__py3-none-any.whl → 2.9.1__py3-none-any.whl

klaude_code/session/session.py

@@ -92,10 +92,6 @@ class Session(BaseModel):
             ]
         return self._user_messages_cache
 
-    @staticmethod
-    def _project_key() -> str:
-        return project_key_from_cwd()
-
     @classmethod
     def paths(cls) -> ProjectPaths:
         return get_default_store().paths
@@ -320,10 +316,15 @@ class Session(BaseModel):
         prev_item: message.HistoryEvent | None = None
         last_assistant_content: str = ""
         report_back_result: str | None = None
+        pending_tool_calls: dict[str, events.ToolCallEvent] = {}
         history = self.conversation_history
         history_len = len(history)
         yield events.TaskStartEvent(session_id=self.id, sub_agent_state=self.sub_agent_state)
         for idx, it in enumerate(history):
+            # Flush pending tool calls if current item won't consume them
+            if pending_tool_calls and not isinstance(it, message.ToolResultMessage):
+                yield from pending_tool_calls.values()
+                pending_tool_calls.clear()
             if self.need_turn_start(prev_item, it):
                 yield events.TurnStartEvent(session_id=self.id)
             match it:
@@ -335,6 +336,7 @@ class Session(BaseModel):
                     # Reconstruct streaming boundaries from saved parts.
                     # This allows replay to reuse the same TUI state machine as live events.
                     thinking_open = False
+                    thinking_had_content = False
                     assistant_open = False
 
                     for part in am.parts:
@@ -346,15 +348,23 @@ class Session(BaseModel):
                                 thinking_open = True
                                 yield events.ThinkingStartEvent(response_id=am.response_id, session_id=self.id)
                             if part.text:
+                                if thinking_had_content:
+                                    yield events.ThinkingDeltaEvent(
+                                        content="  \n  \n",
+                                        response_id=am.response_id,
+                                        session_id=self.id,
+                                    )
                                 yield events.ThinkingDeltaEvent(
                                     content=part.text,
                                     response_id=am.response_id,
                                     session_id=self.id,
                                 )
+                                thinking_had_content = True
                             continue
 
                         if thinking_open:
                             thinking_open = False
+                            thinking_had_content = False
                             yield events.ThinkingEndEvent(response_id=am.response_id, session_id=self.id)
 
                         if isinstance(part, message.TextPart):
@@ -384,7 +394,7 @@ class Session(BaseModel):
                             continue
                         if part.tool_name == tools.REPORT_BACK:
                             report_back_result = part.arguments_json
-                        yield events.ToolCallEvent(
+                        pending_tool_calls[part.call_id] = events.ToolCallEvent(
                             tool_call_id=part.call_id,
                             tool_name=part.tool_name,
                             arguments=part.arguments_json,
@@ -394,6 +404,8 @@ class Session(BaseModel):
                     if am.stop_reason == "aborted":
                         yield events.InterruptEvent(session_id=self.id)
                 case message.ToolResultMessage() as tr:
+                    if tr.call_id in pending_tool_calls:
+                        yield pending_tool_calls.pop(tr.call_id)
                     status = "success" if tr.status == "success" else "error"
                     # Check if this is the last tool result in the current turn
                     next_item = history[idx + 1] if idx + 1 < history_len else None
@@ -410,7 +422,9 @@ class Session(BaseModel):
                     )
                     yield from self._iter_sub_agent_history(tr, seen_sub_agent_sessions)
                 case message.UserMessage() as um:
-                    images = [part for part in um.parts if isinstance(part, message.ImageURLPart)]
+                    images = [
+                        part for part in um.parts if isinstance(part, (message.ImageURLPart, message.ImageFilePart))
+                    ]
                     yield events.UserMessageEvent(
                         content=message.join_text_parts(um.parts),
                         session_id=self.id,
@@ -439,6 +453,11 @@ class Session(BaseModel):
                     pass
             prev_item = it
 
+        # Flush any remaining pending tool calls (e.g., from aborted or incomplete sessions)
+        if pending_tool_calls:
+            yield from pending_tool_calls.values()
+            pending_tool_calls.clear()
+
         has_structured_output = report_back_result is not None
         task_result = report_back_result if has_structured_output else last_assistant_content
 
@@ -608,27 +627,66 @@ class Session(BaseModel):
         return resolved[0]
 
     @classmethod
-    def clean_small_sessions(cls, min_messages: int = 5) -> int:
-        sessions = cls.list_sessions()
-        deleted_count = 0
+    def find_sessions_by_prefix(cls, prefix: str) -> list[str]:
+        """Find main session IDs matching a prefix.
+
+        Args:
+            prefix: Session ID prefix to match.
+
+        Returns:
+            List of matching session IDs, sorted alphabetically.
+        """
+        prefix = (prefix or "").strip().lower()
+        if not prefix:
+            return []
+
         store = get_default_store()
-        for session_meta in sessions:
-            if session_meta.messages_count < 0:
+        matches: set[str] = set()
+
+        for meta_path in store.iter_meta_files():
+            data = _read_json_dict(meta_path)
+            if data is None:
                 continue
-            if session_meta.messages_count < min_messages:
-                store.delete_session(session_meta.id)
-                deleted_count += 1
-        return deleted_count
+            # Exclude sub-agent sessions.
+            if data.get("sub_agent_state") is not None:
+                continue
+            sid = str(data.get("id", meta_path.parent.name)).strip()
+            if sid.lower().startswith(prefix):
+                matches.add(sid)
+
+        return sorted(matches)
 
     @classmethod
-    def clean_all_sessions(cls) -> int:
-        sessions = cls.list_sessions()
-        deleted_count = 0
+    def shortest_unique_prefix(cls, session_id: str, min_length: int = 4) -> str:
+        """Find the shortest unique prefix for a session ID.
+
+        Args:
+            session_id: The session ID to find prefix for.
+            min_length: Minimum prefix length (default 4).
+
+        Returns:
+            The shortest prefix that uniquely identifies this session.
+        """
         store = get_default_store()
-        for session_meta in sessions:
-            store.delete_session(session_meta.id)
-            deleted_count += 1
-        return deleted_count
+        other_ids: list[str] = []
+
+        for meta_path in store.iter_meta_files():
+            data = _read_json_dict(meta_path)
+            if data is None:
+                continue
+            if data.get("sub_agent_state") is not None:
+                continue
+            sid = str(data.get("id", meta_path.parent.name)).strip()
+            if sid != session_id:
+                other_ids.append(sid.lower())
+
+        session_lower = session_id.lower()
+        for length in range(min_length, len(session_id) + 1):
+            prefix = session_lower[:length]
+            if not any(other.startswith(prefix) for other in other_ids):
+                return session_id[:length]
+
+        return session_id
 
     @classmethod
     def exports_dir(cls) -> Path:

klaude_code/session/store.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import asyncio
 import json
-import shutil
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass
 from pathlib import Path
@@ -152,9 +151,6 @@ class JsonlSessionStore:
             return []
         return sessions_dir.glob("*/meta.json")
 
-    def delete_session(self, session_id: str) -> None:
-        shutil.rmtree(self._paths.session_dir(session_id), ignore_errors=True)
-
     async def aclose(self) -> None:
         await self._writer.aclose()
 

klaude_code/skill/assets/deslop/SKILL.md

@@ -12,6 +12,15 @@ Remove AI-generated slop from code. Check the specified files or diff and remove
 - Extra comments that a human wouldn't add or are inconsistent with the rest of the file
 - Extra defensive checks or try/catch blocks that are abnormal for that area of the codebase (especially if called by trusted/validated codepaths)
 - Casts to `any` or `# type: ignore` to get around type issues
+- Unnecessary complexity and nesting that reduces readability
+- Redundant abstractions or over-engineered solutions
 - Any other style that is inconsistent with the file
 
+## Principles
+
+1. **Preserve functionality**: Never change what the code does - only how it does it
+2. **Prefer clarity over brevity**: Explicit readable code is better than overly compact solutions
+3. **Avoid over-simplification**: Don't create overly clever solutions that are hard to understand or debug
+4. **Focus scope**: Only refine the specified files or recently modified code, unless instructed otherwise
+
 Report at the end with only a 1-3 sentence summary of what you changed.

klaude_code/skill/system_skills.py

@@ -170,23 +170,3 @@ def install_system_skills() -> bool:
 
         log_debug("System skills installation complete")
         return True
-
-
-def get_installed_system_skills() -> list[Path]:
-    """Get list of installed system skill directories.
-
-    Returns:
-        List of paths to installed skill directories
-    """
-    dest_dir = get_system_skills_dir()
-    if not dest_dir.exists():
-        return []
-
-    skills: list[Path] = []
-    for item in dest_dir.iterdir():
-        if item.is_dir() and not item.name.startswith("."):
-            skill_file = item / "SKILL.md"
-            if skill_file.exists():
-                skills.append(item)
-
-    return skills

klaude_code/tui/command/fork_session_cmd.py

@@ -6,6 +6,7 @@ from typing import Literal
 from prompt_toolkit.styles import Style, merge_styles
 
 from klaude_code.protocol import commands, events, message, model
+from klaude_code.session import Session
 from klaude_code.tui.input.key_bindings import copy_to_clipboard
 from klaude_code.tui.terminal.selector import DEFAULT_PICKER_STYLE, SelectItem, select_one
 
@@ -312,7 +313,8 @@ class ForkSessionCommand(CommandABC):
             new_session = agent.session.fork()
             await new_session.wait_for_flush()
 
-            resume_cmd = f"klaude --resume {new_session.id}"
+            short_id = Session.shortest_unique_prefix(new_session.id)
+            resume_cmd = f"klaude -r {short_id}"
             copy_to_clipboard(resume_cmd)
 
             event = events.CommandOutputEvent(
@@ -345,7 +347,8 @@ class ForkSessionCommand(CommandABC):
         else:
             fork_description = "entire conversation" if selected == -1 else f"up to message index {selected}"
 
-        resume_cmd = f"klaude --resume {new_session.id}"
+        short_id = Session.shortest_unique_prefix(new_session.id)
+        resume_cmd = f"klaude -r {short_id}"
         copy_to_clipboard(resume_cmd)
 
         event = events.CommandOutputEvent(

klaude_code/tui/command/resume_cmd.py

@@ -8,9 +8,16 @@ from klaude_code.tui.terminal.selector import DEFAULT_PICKER_STYLE, SelectItem,
 from .command_abc import Agent, CommandABC, CommandResult
 
 
-def select_session_sync() -> str | None:
-    """Interactive session selection (sync version for asyncio.to_thread)."""
+def select_session_sync(session_ids: list[str] | None = None) -> str | None:
+    """Interactive session selection (sync version for asyncio.to_thread).
+
+    Args:
+        session_ids: Optional list of session IDs to filter. If provided, only show these sessions.
+    """
     options = build_session_select_options()
+    if session_ids is not None:
+        session_id_set = set(session_ids)
+        options = [opt for opt in options if opt.session_id in session_id_set]
     if not options:
         log("No sessions found for this project.")
         return None

klaude_code/tui/command/sub_agent_model_cmd.py

@@ -1,10 +1,10 @@
-"""Command for changing sub-agent models."""
+"""Command for changing sub-agent models and compact model."""
 
 from __future__ import annotations
 
 import asyncio
 
-from klaude_code.config.config import load_config
+from klaude_code.config.config import Config, load_config
 from klaude_code.config.sub_agent_model_helper import SubAgentModelHelper, SubAgentModelInfo
 from klaude_code.protocol import commands, events, message, op
 from klaude_code.tui.terminal.selector import DEFAULT_PICKER_STYLE, SelectItem, build_model_select_items, select_one
@@ -12,16 +12,35 @@ from klaude_code.tui.terminal.selector import DEFAULT_PICKER_STYLE, SelectItem,
 from .command_abc import Agent, CommandABC, CommandResult
 
 USE_DEFAULT_BEHAVIOR = "__default__"
+COMPACT_MODEL_OPTION = "__compact__"
+
+
+def _build_compact_model_item(config: Config, max_name_len: int, main_model_name: str) -> SelectItem[str]:
+    """Build SelectItem for compact model configuration."""
+    name = "Compact"
+    model_display = config.compact_model or f"(inherit from main agent: {main_model_name})"
+
+    title = [
+        ("class:msg", f"{name:<{max_name_len}}"),
+        ("class:meta", f"  current: {model_display}\n"),
+    ]
+    return SelectItem(title=title, value=COMPACT_MODEL_OPTION, search_text="compact")
 
 
 def _build_sub_agent_select_items(
     sub_agents: list[SubAgentModelInfo],
     helper: SubAgentModelHelper,
     main_model_name: str,
+    config: Config,
 ) -> list[SelectItem[str]]:
-    """Build SelectItem list for sub-agent selection."""
+    """Build SelectItem list for sub-agent selection (including compact model)."""
     items: list[SelectItem[str]] = []
+    # Include "Compact" in max_name_len calculation
     max_name_len = max(len(sa.profile.name) for sa in sub_agents) if sub_agents else 0
+    max_name_len = max(max_name_len, len("Compact"))
+
+    # Add compact model option first
+    items.append(_build_compact_model_item(config, max_name_len, main_model_name))
 
     for sa in sub_agents:
         name = sa.profile.name
@@ -45,9 +64,10 @@ def _select_sub_agent_sync(
     sub_agents: list[SubAgentModelInfo],
     helper: SubAgentModelHelper,
     main_model_name: str,
+    config: Config,
 ) -> str | None:
-    """Synchronous sub-agent type selection."""
-    items = _build_sub_agent_select_items(sub_agents, helper, main_model_name)
+    """Synchronous sub-agent type selection (including compact model)."""
+    items = _build_sub_agent_select_items(sub_agents, helper, main_model_name, config)
     if not items:
         return None
 
@@ -98,8 +118,39 @@ def _select_model_for_sub_agent_sync(
         return None
 
 
+def _select_model_for_compact_sync(
+    config: Config,
+    main_model_name: str,
+) -> str | None:
+    """Synchronous model selection for compact model."""
+    models = config.iter_model_entries(only_available=True, include_disabled=False)
+
+    inherit_item = SelectItem[str](
+        title=[
+            ("class:msg", "(Use default behavior)"),
+            ("class:meta", f"  -> inherit from main agent: {main_model_name}\n"),
+        ],
+        value=USE_DEFAULT_BEHAVIOR,
+        search_text="default unset",
+    )
+    model_items = build_model_select_items(models)
+    all_items = [inherit_item, *model_items]
+
+    try:
+        result = select_one(
+            message="Select model for Compact:",
+            items=all_items,
+            pointer="→",
+            style=DEFAULT_PICKER_STYLE,
+            use_search_filter=True,
+        )
+        return result if isinstance(result, str) else None
+    except KeyboardInterrupt:
+        return None
+
+
 class SubAgentModelCommand(CommandABC):
-    """Configure models for sub-agents (Task, Explore, WebAgent, ImageGen)."""
+    """Configure models for sub-agents (Task, Explore, Web, ImageGen) and compact model."""
 
     @property
     def name(self) -> commands.CommandName:
@@ -119,32 +170,48 @@ class SubAgentModelCommand(CommandABC):
         main_model_name = agent.get_llm_client().model_name
 
         sub_agents = helper.get_available_sub_agents()
-        if not sub_agents:
+
+        selected_option = await asyncio.to_thread(_select_sub_agent_sync, sub_agents, helper, main_model_name, config)
+        if selected_option is None:
             return CommandResult(
                 events=[
                     events.CommandOutputEvent(
                         session_id=agent.session.id,
                         command_name=self.name,
-                        content="No sub-agents available",
-                        is_error=True,
+                        content="(cancelled)",
                     )
                 ]
             )
 
-        selected_sub_agent = await asyncio.to_thread(_select_sub_agent_sync, sub_agents, helper, main_model_name)
-        if selected_sub_agent is None:
+        # Handle compact model selection
+        if selected_option == COMPACT_MODEL_OPTION:
+            selected_model = await asyncio.to_thread(_select_model_for_compact_sync, config, main_model_name)
+            if selected_model is None:
+                return CommandResult(
+                    events=[
+                        events.CommandOutputEvent(
+                            session_id=agent.session.id,
+                            command_name=self.name,
+                            content="(cancelled)",
+                        )
+                    ]
+                )
+
+            model_name: str | None = None if selected_model == USE_DEFAULT_BEHAVIOR else selected_model
+
             return CommandResult(
-                events=[
-                    events.CommandOutputEvent(
+                operations=[
+                    op.ChangeCompactModelOperation(
                         session_id=agent.session.id,
-                        command_name=self.name,
-                        content="(cancelled)",
+                        model_name=model_name,
+                        save_as_default=True,
                     )
                 ]
             )
 
+        # Handle sub-agent model selection
         selected_model = await asyncio.to_thread(
-            _select_model_for_sub_agent_sync, helper, selected_sub_agent, main_model_name
+            _select_model_for_sub_agent_sync, helper, selected_option, main_model_name
         )
         if selected_model is None:
             return CommandResult(
@@ -157,13 +224,13 @@ class SubAgentModelCommand(CommandABC):
                 ]
             )
 
-        model_name: str | None = None if selected_model == USE_DEFAULT_BEHAVIOR else selected_model
+        model_name = None if selected_model == USE_DEFAULT_BEHAVIOR else selected_model
 
         return CommandResult(
             operations=[
                 op.ChangeSubAgentModelOperation(
                     session_id=agent.session.id,
-                    sub_agent_type=selected_sub_agent,
+                    sub_agent_type=selected_option,
                     model_name=model_name,
                     save_as_default=True,
                 )

klaude_code/tui/components/assistant.py

@@ -1,28 +1,2 @@
-from rich.console import RenderableType
-from rich.padding import Padding
-from rich.text import Text
-
-from klaude_code.const import MARKDOWN_RIGHT_MARGIN
-from klaude_code.tui.components.common import create_grid
-from klaude_code.tui.components.rich.markdown import NoInsetMarkdown
-from klaude_code.tui.components.rich.theme import ThemeKey
-
 # UI markers
 ASSISTANT_MESSAGE_MARK = "•"
-
-
-def render_assistant_message(content: str, *, code_theme: str) -> RenderableType | None:
-    """Render assistant message for replay history display.
-
-    Returns None if content is empty.
-    """
-    stripped = content.strip()
-    if len(stripped) == 0:
-        return None
-
-    grid = create_grid()
-    grid.add_row(
-        Text(ASSISTANT_MESSAGE_MARK, style=ThemeKey.ASSISTANT_MESSAGE_MARK),
-        Padding(NoInsetMarkdown(stripped, code_theme=code_theme), (0, MARKDOWN_RIGHT_MARGIN, 0, 0)),
-    )
-    return grid

klaude_code/tui/components/bash_syntax.py

@@ -187,6 +187,10 @@ def highlight_bash_command(command: str) -> Text:
                 expect_subcommand = False
         elif token_type in (Token.Text.Whitespace,):
             result.append(token_value)
+            # Newline starts a new command context (like ; or &&)
+            if "\n" in token_value:
+                expect_command = True
+                expect_subcommand = False
         elif token_type == Token.Name.Builtin:
             # Built-in commands are always commands
             result.append(token_value, style=ThemeKey.BASH_COMMAND)

klaude_code/tui/components/command_output.py

@@ -4,6 +4,7 @@ from rich.table import Table
 from rich.text import Text
 
 from klaude_code.protocol import events, model
+from klaude_code.session import Session
 from klaude_code.tui.components.common import truncate_middle
 from klaude_code.tui.components.rich.theme import ThemeKey
 
@@ -47,10 +48,11 @@ def _render_fork_session_output(e: events.CommandOutputEvent) -> RenderableType:
 
     grid = Table.grid(padding=(0, 1))
     session_id = e.ui_extra.session_id
+    short_id = Session.shortest_unique_prefix(session_id)
     grid.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
 
     grid.add_row(Text("Session forked. Resume command copied to clipboard:", style=ThemeKey.TOOL_RESULT))
-    grid.add_row(Text(f"  klaude --resume {session_id}", style=ThemeKey.TOOL_RESULT_BOLD))
+    grid.add_row(Text(f"  klaude -r {short_id}", style=ThemeKey.TOOL_RESULT_BOLD))
 
     return Padding.indent(grid, level=2)
 

klaude_code/tui/components/developer.py

@@ -115,5 +115,8 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
                         ),
                     )
                     parts.append(grid)
+                case model.AtFileImagesUIItem():
+                    # Image display is handled by renderer.display_developer_message
+                    pass
 
     return Group(*parts) if parts else Text("")