klaude-code 1.2.9__py3-none-any.whl → 1.2.11__py3-none-any.whl

klaude_code/cli/main.py

@@ -3,7 +3,7 @@ import datetime
 import os
 import subprocess
 import sys
-import uuid
+from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as pkg_version
 
 import typer
@@ -27,6 +27,9 @@ def _version_callback(value: bool) -> None:
     if value:
         try:
             ver = pkg_version("klaude-code")
+        except PackageNotFoundError:
+            # Package is not installed or has no metadata; show a generic version string.
+            ver = "unknown"
         except Exception:
             ver = "unknown"
         print(f"klaude-code {ver}")
@@ -232,8 +235,12 @@ def exec_command(
             stdin = sys.stdin.read().rstrip("\n")
             if stdin:
                 parts.append(stdin)
-        except Exception as e:
+        except (OSError, ValueError) as e:
+            # Expected I/O-related errors when reading from stdin (e.g. broken pipe, closed stream).
             log((f"Error reading from stdin: {e}", "red"))
+        except Exception as e:
+            # Unexpected errors are still reported but kept from crashing the CLI.
+            log((f"Unexpected error reading from stdin: {e}", "red"))
 
     if input_content:
         parts.append(input_content)
@@ -332,6 +339,7 @@ def main_callback(
                 return
 
         # Resolve session id before entering asyncio loop
+        # session_id=None means create a new session
         session_id: str | None = None
         if resume:
             session_id = resume_select_session()
@@ -340,9 +348,7 @@ def main_callback(
         # If user didn't pick, allow fallback to --continue
         if session_id is None and continue_:
             session_id = Session.most_recent_session_id()
-        # If still no session_id, generate a new one for a new session
-        if session_id is None:
-            session_id = uuid.uuid4().hex
+        # If still no session_id, leave as None to create a new session
 
         debug_enabled, debug_filters = resolve_debug_settings(debug, debug_filter)
 

klaude_code/cli/runtime.py

@@ -1,6 +1,5 @@
 import asyncio
 import sys
-import uuid
 from dataclasses import dataclass
 from typing import Any, Protocol
 
@@ -13,10 +12,8 @@ from klaude_code.config import Config, load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, VanillaModelProfileProvider
 from klaude_code.core.executor import Executor
 from klaude_code.core.manager import build_llm_clients
-from klaude_code.core.tool import SkillLoader, SkillTool
 from klaude_code.protocol import events, op
 from klaude_code.protocol.model import UserInputPayload
-from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 from klaude_code.trace import DebugType, log, set_debug_logging
 from klaude_code.ui.modes.repl import build_repl_status_snapshot
 from klaude_code.ui.modes.repl.input_prompt_toolkit import REPLStatusSnapshot
@@ -96,18 +93,11 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
     if config is None:
         raise typer.Exit(1)
 
-    # Initialize skills
-    skill_loader = SkillLoader()
-    skill_loader.discover_skills()
-    SkillTool.set_skill_loader(skill_loader)
-
     # Initialize LLM clients
     try:
-        enabled_sub_agents = [p.name for p in iter_sub_agent_profiles()]
         llm_clients = build_llm_clients(
             config,
             model_override=init_config.model,
-            enabled_sub_agents=enabled_sub_agents,
         )
     except ValueError as exc:
         if init_config.model:
@@ -213,13 +203,14 @@ async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
     components = await initialize_app_components(init_config)
 
     try:
-        # Generate a new session ID for exec mode
-        session_id = uuid.uuid4().hex
-
-        # Init Agent
-        await components.executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
+        # Initialize a new session (session_id=None means create new)
+        await components.executor.submit_and_wait(op.InitAgentOperation())
         await components.event_queue.join()
 
+        # Get the session_id from the newly created agent
+        session_ids = components.executor.context.agent_manager.active_session_ids()
+        session_id = session_ids[0] if session_ids else None
+
         # Submit the input content directly
         await components.executor.submit_and_wait(
             op.UserInputOperation(input=UserInputPayload(text=input_content), session_id=session_id)
@@ -232,8 +223,11 @@ async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
 
 
 async def run_interactive(init_config: AppInitConfig, session_id: str | None = None) -> None:
-    """Run the interactive REPL using the provided configuration."""
+    """Run the interactive REPL using the provided configuration.
 
+    If session_id is None, a new session is created with an auto-generated ID.
+    If session_id is provided, attempts to resume that session.
+    """
     components = await initialize_app_components(init_config)
 
     # No theme persistence from CLI anymore; config.theme controls theme when set.
@@ -241,8 +235,10 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
     # Create status provider for bottom toolbar
     def _status_provider() -> REPLStatusSnapshot:
         agent: Agent | None = None
-        if session_id and session_id in components.executor.context.active_agents:
-            agent = components.executor.context.active_agents[session_id]
+        # Get the first active agent (there should only be one in interactive mode)
+        active_agents = components.executor.context.active_agents
+        if active_agents:
+            agent = next(iter(active_agents.values()), None)
 
         # Check for updates (returns None if uv not available)
         update_message = get_update_message()
@@ -284,9 +280,13 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
     restore_sigint = install_sigint_double_press_exit(_show_toast_once, _hide_progress)
 
     try:
-        # Init Agent
         await components.executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
         await components.event_queue.join()
+
+        # Get the actual session_id (may have been auto-generated if None was passed)
+        active_session_ids = components.executor.context.agent_manager.active_session_ids()
+        active_session_id = active_session_ids[0] if active_session_ids else session_id
+
         # Input
         await input_provider.start()
         async for user_input in input_provider.iter_inputs():
@@ -297,7 +297,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
                 continue
             # Submit user input operation - directly use the payload from iter_inputs
             submission_id = await components.executor.submit(
-                op.UserInputOperation(input=user_input, session_id=session_id)
+                op.UserInputOperation(input=user_input, session_id=active_session_id)
             )
             # If it's an interactive command (e.g., /model), avoid starting the ESC monitor
             # to prevent TTY conflicts with interactive prompts (questionary/prompt_toolkit).
@@ -306,7 +306,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             else:
                 # Esc monitor for long-running, interruptible operations
                 async def _on_esc_interrupt() -> None:
-                    await components.executor.submit(op.InterruptOperation(target_session_id=session_id))
+                    await components.executor.submit(op.InterruptOperation(target_session_id=active_session_id))
 
                 stop_event, esc_task = start_esc_interrupt_monitor(_on_esc_interrupt)
                 # Wait for this specific task to complete before accepting next input

klaude_code/command/__init__.py

@@ -1,13 +1,4 @@
-from .clear_cmd import ClearCommand
 from .command_abc import CommandABC, CommandResult, InputAction, InputActionType
-from .diff_cmd import DiffCommand
-from .export_cmd import ExportCommand
-from .help_cmd import HelpCommand
-
-# InitCommand is now dynamically loaded via prompt_init.md
-# from .init_cmd import InitCommand
-from .model_cmd import ModelCommand
-from .refresh_cmd import RefreshTerminalCommand
 from .registry import (
     dispatch_command,
     get_commands,
@@ -16,23 +7,76 @@ from .registry import (
     load_prompt_commands,
     register_command,
 )
-from .release_notes_cmd import ReleaseNotesCommand
-from .status_cmd import StatusCommand
-from .terminal_setup_cmd import TerminalSetupCommand
 
-# Dynamically load prompt commands
-load_prompt_commands()
+# Lazy load commands to avoid heavy imports at module load time
+_commands_loaded = False
+
+
+def ensure_commands_loaded() -> None:
+    """Ensure all commands are loaded (lazy initialization).
+
+    This function is called internally by registry functions like get_commands(),
+    dispatch_command(), etc. It can also be called explicitly if early loading is desired.
+    """
+    global _commands_loaded
+    if _commands_loaded:
+        return
+    _commands_loaded = True
+
+    # Import command modules to trigger @register_command decorators
+    from . import clear_cmd as _clear_cmd  # noqa: F401
+    from . import diff_cmd as _diff_cmd  # noqa: F401
+    from . import export_cmd as _export_cmd  # noqa: F401
+    from . import help_cmd as _help_cmd  # noqa: F401
+    from . import model_cmd as _model_cmd  # noqa: F401
+    from . import refresh_cmd as _refresh_cmd  # noqa: F401
+    from . import release_notes_cmd as _release_notes_cmd  # noqa: F401
+    from . import status_cmd as _status_cmd  # noqa: F401
+    from . import terminal_setup_cmd as _terminal_setup_cmd  # noqa: F401
+
+    # Suppress unused variable warnings
+    _ = (
+        _clear_cmd,
+        _diff_cmd,
+        _export_cmd,
+        _help_cmd,
+        _model_cmd,
+        _refresh_cmd,
+        _release_notes_cmd,
+        _status_cmd,
+        _terminal_setup_cmd,
+    )
+
+    # Load prompt-based commands
+    load_prompt_commands()
+
+
+# Lazy accessors for command classes
+def __getattr__(name: str) -> object:
+    _commands_map = {
+        "ClearCommand": "clear_cmd",
+        "DiffCommand": "diff_cmd",
+        "ExportCommand": "export_cmd",
+        "HelpCommand": "help_cmd",
+        "ModelCommand": "model_cmd",
+        "RefreshTerminalCommand": "refresh_cmd",
+        "ReleaseNotesCommand": "release_notes_cmd",
+        "StatusCommand": "status_cmd",
+        "TerminalSetupCommand": "terminal_setup_cmd",
+    }
+    if name in _commands_map:
+        import importlib
+
+        module = importlib.import_module(f".{_commands_map[name]}", __package__)
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
 
 __all__ = [
-    "ClearCommand",
-    "DiffCommand",
-    "HelpCommand",
-    "ModelCommand",
-    "ExportCommand",
-    "RefreshTerminalCommand",
-    "ReleaseNotesCommand",
-    "StatusCommand",
-    "TerminalSetupCommand",
+    # Command classes are lazily loaded via __getattr__
+    # "ClearCommand", "DiffCommand", "HelpCommand", "ModelCommand",
+    # "ExportCommand", "RefreshTerminalCommand", "ReleaseNotesCommand",
+    # "StatusCommand", "TerminalSetupCommand",
     "register_command",
     "CommandABC",
     "CommandResult",
@@ -42,4 +86,5 @@ __all__ = [
     "get_commands",
     "is_slash_command_name",
     "has_interactive_command",
+    "ensure_commands_loaded",
 ]

klaude_code/command/clear_cmd.py

@@ -1,8 +1,12 @@
+from typing import TYPE_CHECKING
+
 from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class ClearCommand(CommandABC):
@@ -16,5 +20,5 @@ class ClearCommand(CommandABC):
     def summary(self) -> str:
         return "Clear conversation history and free up context"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         return CommandResult(actions=[InputAction.clear()])

klaude_code/command/command_abc.py

@@ -1,12 +1,15 @@
 from abc import ABC, abstractmethod
 from enum import Enum
+from typing import TYPE_CHECKING
 
 from pydantic import BaseModel
 
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands
 from klaude_code.protocol import events as protocol_events
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 class InputActionType(str, Enum):
     """Supported input action kinds."""
@@ -78,7 +81,7 @@ class CommandABC(ABC):
         return False
 
     @abstractmethod
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         """
         Execute the command.
 

klaude_code/command/diff_cmd.py

@@ -1,11 +1,14 @@
 import subprocess
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class DiffCommand(CommandABC):
@@ -19,7 +22,7 @@ class DiffCommand(CommandABC):
     def summary(self) -> str:
         return "Show git diff"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         try:
             # Check if current directory is in a git repository
             git_check = subprocess.run(

klaude_code/command/export_cmd.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 import subprocess
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
 from klaude_code.session.export import build_export_html, get_default_export_path
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class ExportCommand(CommandABC):
@@ -30,7 +33,7 @@ class ExportCommand(CommandABC):
     def is_interactive(self) -> bool:
         return False
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         try:
             output_path = self._resolve_output_path(raw, agent)
             html_doc = self._build_html(agent)
@@ -57,7 +60,7 @@ class ExportCommand(CommandABC):
             )
             return CommandResult(events=[event])
 
-    def _resolve_output_path(self, raw: str, agent: Agent) -> Path:
+    def _resolve_output_path(self, raw: str, agent: "Agent") -> Path:
         trimmed = raw.strip()
         if trimmed:
             candidate = Path(trimmed).expanduser()
@@ -78,7 +81,7 @@ class ExportCommand(CommandABC):
             msg = f"Failed to open HTML with `open`: {exc}"
             raise RuntimeError(msg) from exc
 
-    def _build_html(self, agent: Agent) -> str:
+    def _build_html(self, agent: "Agent") -> str:
         profile = agent.profile
         system_prompt = (profile.system_prompt if profile else "") or ""
         tools = profile.tools if profile else []

klaude_code/command/help_cmd.py

@@ -1,8 +1,12 @@
+from typing import TYPE_CHECKING
+
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class HelpCommand(CommandABC):
@@ -16,7 +20,7 @@ class HelpCommand(CommandABC):
     def summary(self) -> str:
         return "Show help and available commands"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         lines: list[str] = [
             """
 Usage:

klaude_code/command/model_cmd.py

@@ -1,11 +1,14 @@
 import asyncio
+from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
 from klaude_code.command.registry import register_command
 from klaude_code.config import select_model_from_config
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class ModelCommand(CommandABC):
@@ -23,7 +26,7 @@ class ModelCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         selected_model = await asyncio.to_thread(select_model_from_config, preferred=raw)
 
         current_model = agent.profile.llm_client.model_name if agent.profile else None

klaude_code/command/prompt_command.py

@@ -1,10 +1,14 @@
 from importlib.resources import files
+from typing import TYPE_CHECKING
 
 import yaml
 
 from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands
+from klaude_code.trace import log_debug
+
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
 
 
 class PromptCommand(CommandABC):
@@ -41,7 +45,8 @@ class PromptCommand(CommandABC):
 
             self._metadata = {}
             self._content = raw_text
-        except Exception:
+        except (OSError, yaml.YAMLError) as e:
+            log_debug(f"Failed to load prompt template {self.template_name}: {e}")
             self._metadata = {"description": "Error loading template"}
             self._content = f"Error loading template: {self.template_name}"
 
@@ -54,7 +59,7 @@ class PromptCommand(CommandABC):
     def support_addition_params(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         self._ensure_loaded()
         template_content = self._content or ""
         user_input = raw.strip() or "<none>"

klaude_code/command/refresh_cmd.py

@@ -1,8 +1,12 @@
+from typing import TYPE_CHECKING
+
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class RefreshTerminalCommand(CommandABC):
@@ -20,7 +24,7 @@ class RefreshTerminalCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         import os
 
         os.system("cls" if os.name == "nt" else "clear")

klaude_code/command/registry.py

@@ -3,10 +3,12 @@ from typing import TYPE_CHECKING, TypeVar
 
 from klaude_code.command.command_abc import CommandResult, InputAction
 from klaude_code.command.prompt_command import PromptCommand
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
+from klaude_code.trace import log_debug
 
 if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
     from .command_abc import CommandABC
 
 _COMMANDS: dict[commands.CommandName | str, "CommandABC"] = {}
@@ -30,21 +32,30 @@ def load_prompt_commands():
             if (name.startswith("prompt_") or name.startswith("prompt-")) and name.endswith(".md"):
                 cmd = PromptCommand(name)
                 _COMMANDS[cmd.name] = cmd
-    except Exception:
-        # If resource loading fails, just ignore
-        pass
+    except OSError as e:
+        log_debug(f"Failed to load prompt commands: {e}")
+
+
+def _ensure_commands_loaded() -> None:
+    """Ensure all commands are loaded (lazy initialization)."""
+    from klaude_code.command import ensure_commands_loaded
+
+    ensure_commands_loaded()
 
 
 def get_commands() -> dict[commands.CommandName | str, "CommandABC"]:
     """Get all registered commands."""
+    _ensure_commands_loaded()
     return _COMMANDS.copy()
 
 
 def is_slash_command_name(name: str) -> bool:
+    _ensure_commands_loaded()
     return name in _COMMANDS
 
 
-async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
+async def dispatch_command(raw: str, agent: "Agent") -> CommandResult:
+    _ensure_commands_loaded()
     # Detect command name
     if not raw.startswith("/"):
         return CommandResult(actions=[InputAction.run_agent(raw)])
@@ -96,6 +107,7 @@ async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
 
 
 def has_interactive_command(raw: str) -> bool:
+    _ensure_commands_loaded()
     if not raw.startswith("/"):
         return False
     splits = raw.split(" ", maxsplit=1)

klaude_code/command/release_notes_cmd.py

@@ -1,10 +1,13 @@
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 def _read_changelog() -> str:
     """Read CHANGELOG.md from project root."""
@@ -71,7 +74,7 @@ class ReleaseNotesCommand(CommandABC):
     def summary(self) -> str:
         return "Show the latest release notes"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         changelog = _read_changelog()
         content = _extract_releases(changelog, count=10)
 

klaude_code/command/status_cmd.py

@@ -1,9 +1,13 @@
+from typing import TYPE_CHECKING
+
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
 from klaude_code.session.session import Session
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 class AggregatedUsage(model.BaseModel):
     """Aggregated usage statistics including per-model breakdown."""
@@ -56,8 +60,8 @@ def accumulate_session_usage(session: Session) -> AggregatedUsage:
             total.cache_read_cost = (total.cache_read_cost or 0.0) + usage.cache_read_cost
 
         # Track peak context window size (max across all tasks)
-        if usage.context_window_size is not None:
-            total.context_window_size = usage.context_window_size
+        if usage.context_token is not None:
+            total.context_token = usage.context_token
 
         # Keep the latest context_limit for computed context_usage_percent
         if usage.context_limit is not None:
@@ -135,7 +139,7 @@ class StatusCommand(CommandABC):
     def summary(self) -> str:
         return "Show session usage statistics"
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         session = agent.session
         aggregated = accumulate_session_usage(session)
 

klaude_code/command/terminal_setup_cmd.py

@@ -1,12 +1,15 @@
 import os
 import subprocess
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult
 from klaude_code.command.registry import register_command
-from klaude_code.core.agent import Agent
 from klaude_code.protocol import commands, events, model
 
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
 
 @register_command
 class TerminalSetupCommand(CommandABC):
@@ -24,7 +27,7 @@ class TerminalSetupCommand(CommandABC):
     def is_interactive(self) -> bool:
         return False
 
-    async def run(self, raw: str, agent: Agent) -> CommandResult:
+    async def run(self, raw: str, agent: "Agent") -> CommandResult:
         term_program = os.environ.get("TERM_PROGRAM", "").lower()
 
         try:
@@ -223,7 +226,7 @@ class TerminalSetupCommand(CommandABC):
 
         return message
 
-    def _create_success_result(self, agent: Agent, message: str) -> CommandResult:
+    def _create_success_result(self, agent: "Agent", message: str) -> CommandResult:
         """Create success result"""
         return CommandResult(
             events=[
@@ -237,7 +240,7 @@ class TerminalSetupCommand(CommandABC):
             ]
         )
 
-    def _create_error_result(self, agent: Agent, message: str) -> CommandResult:
+    def _create_error_result(self, agent: "Agent", message: str) -> CommandResult:
         """Create error result"""
         return CommandResult(
             events=[

klaude_code/const/__init__.py

@@ -91,7 +91,7 @@ INVALID_TOOL_CALL_MAX_LENGTH = 500
 TRUNCATE_DISPLAY_MAX_LINE_LENGTH = 1000
 
 # Maximum lines for truncated display output
-TRUNCATE_DISPLAY_MAX_LINES = 10
+TRUNCATE_DISPLAY_MAX_LINES = 20
 
 # Maximum lines for sub-agent result display
 SUB_AGENT_RESULT_MAX_LINES = 12