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

klaude_code/auth/codex/__init__.py

@@ -17,4 +17,4 @@ __all__ = [
     "CodexOAuthError",
     "CodexTokenExpiredError",
     "CodexTokenManager",
-]
+]

klaude_code/command/__init__.py

@@ -16,6 +16,7 @@ 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
 
@@ -29,6 +30,7 @@ __all__ = [
     "ModelCommand",
     "ExportCommand",
     "RefreshTerminalCommand",
+    "ReleaseNotesCommand",
     "StatusCommand",
     "TerminalSetupCommand",
     "register_command",

klaude_code/command/prompt-deslop.md

@@ -0,0 +1,14 @@
+---
+description: Remove AI code slop
+from: https://cursor.com/cn/link/command?name=deslop&text=%23%20Remove%20AI%20code%20slop%0A%0ACheck%20the%20diff%20against%20main%2C%20and%20remove%20all%20AI%20generated%20slop%20introduced%20in%20this%20branch.%0A%0AThis%20includes%3A%0A-%20Extra%20comments%20that%20a%20human%20wouldn%27t%20add%20or%20is%20inconsistent%20with%20the%20rest%20of%20the%20file%0A-%20Extra%20defensive%20checks%20or%20try%2Fcatch%20blocks%20that%20are%20abnormal%20for%20that%20area%20of%20the%20codebase%20(especially%20if%20called%20by%20trusted%20%2F%20validated%20codepaths)%0A-%20Casts%20to%20any%20to%20get%20around%20type%20issues%0A-%20Any%20other%20style%20that%20is%20inconsistent%20with%20the%20file%0A%0AReport%20at%20the%20end%20with%20only%20a%201-3%20sentence%20summary%20of%20what%20you%20changed
+---
+
+Check the diff against main, and remove all AI generated slop introduced in this branch.
+
+This includes:
+- Extra comments that a human wouldn't add or is 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 to get around type issues
+- Any other style that is inconsistent with the file
+
+Report at the end with only a 1-3 sentence summary of what you changed

klaude_code/command/release_notes_cmd.py

@@ -0,0 +1,86 @@
+from pathlib import Path
+
+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
+
+
+def _read_changelog() -> str:
+    """Read CHANGELOG.md from project root."""
+    changelog_path = Path(__file__).parent.parent.parent.parent / "CHANGELOG.md"
+    if not changelog_path.exists():
+        return "CHANGELOG.md not found"
+    return changelog_path.read_text(encoding="utf-8")
+
+
+def _extract_releases(changelog: str, count: int = 1) -> str:
+    """Extract release sections from changelog in reverse order (oldest first).
+
+    Args:
+        changelog: The full changelog content.
+        count: Number of releases to extract (default 1).
+
+    Returns:
+        The content of the specified number of releases, with newest at bottom.
+    """
+    lines = changelog.split("\n")
+    releases: list[list[str]] = []
+    current_release: list[str] = []
+    version_count = 0
+
+    for line in lines:
+        # Skip [Unreleased] section header
+        if line.startswith("## [Unreleased]"):
+            continue
+
+        # Check for version header (e.g., ## [1.2.8] - 2025-12-01)
+        if line.startswith("## [") and "]" in line:
+            if current_release:
+                releases.append(current_release)
+            version_count += 1
+            if version_count > count:
+                break
+            current_release = [line]
+            continue
+
+        if version_count > 0:
+            current_release.append(line)
+
+    # Append the last release if exists
+    if current_release and version_count <= count:
+        releases.append(current_release)
+
+    if not releases:
+        return "No release notes found"
+
+    # Reverse to show oldest first, newest last
+    releases.reverse()
+    return "\n".join("\n".join(release) for release in releases).strip()
+
+
+@register_command
+class ReleaseNotesCommand(CommandABC):
+    """Display the latest release notes from CHANGELOG.md."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.RELEASE_NOTES
+
+    @property
+    def summary(self) -> str:
+        return "Show the latest release notes"
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        changelog = _read_changelog()
+        content = _extract_releases(changelog, count=10)
+
+        event = events.DeveloperMessageEvent(
+            session_id=agent.session.id,
+            item=model.DeveloperMessageItem(
+                content=content,
+                command_output=model.CommandOutput(command_name=self.name),
+            ),
+        )
+
+        return CommandResult(events=[event])

klaude_code/command/status_cmd.py

@@ -5,47 +5,65 @@ from klaude_code.protocol import commands, events, model
 from klaude_code.session.session import Session
 
 
-def accumulate_session_usage(session: Session) -> tuple[model.Usage, int]:
-    """Accumulate usage statistics from all ResponseMetadataItems in session history.
+class AggregatedUsage(model.BaseModel):
+    """Aggregated usage statistics including per-model breakdown."""
 
-    Returns:
-        A tuple of (accumulated_usage, task_count)
+    total: model.Usage
+    by_model: list[model.TaskMetadata]
+    task_count: int
+
+
+def accumulate_session_usage(session: Session) -> AggregatedUsage:
+    """Accumulate usage statistics from all TaskMetadataItems in session history.
+
+    Includes both main agent and sub-agent task metadata, grouped by model+provider.
     """
-    total = model.Usage()
+    all_metadata: list[model.TaskMetadata] = []
     task_count = 0
-    first_currency_set = False
 
     for item in session.conversation_history:
-        if isinstance(item, model.ResponseMetadataItem) and item.usage:
+        if isinstance(item, model.TaskMetadataItem):
             task_count += 1
-            usage = item.usage
-            
-            # Set currency from first usage item
-            if not first_currency_set and usage.currency:
-                total.currency = usage.currency
-                first_currency_set = True
-            
-            total.input_tokens += usage.input_tokens
-            total.cached_tokens += usage.cached_tokens
-            total.reasoning_tokens += usage.reasoning_tokens
-            total.output_tokens += usage.output_tokens
-            total.total_tokens += usage.total_tokens
-
-            # Accumulate costs
-            if usage.input_cost is not None:
-                total.input_cost = (total.input_cost or 0.0) + usage.input_cost
-            if usage.output_cost is not None:
-                total.output_cost = (total.output_cost or 0.0) + usage.output_cost
-            if usage.cache_read_cost is not None:
-                total.cache_read_cost = (total.cache_read_cost or 0.0) + usage.cache_read_cost
-            if usage.total_cost is not None:
-                total.total_cost = (total.total_cost or 0.0) + usage.total_cost
-
-            # Keep the latest context_usage_percent
-            if usage.context_usage_percent is not None:
-                total.context_usage_percent = usage.context_usage_percent
-
-    return total, task_count
+            all_metadata.append(item.main)
+            all_metadata.extend(item.sub_agent_task_metadata)
+
+    # Aggregate by model+provider
+    by_model = model.TaskMetadata.aggregate_by_model(all_metadata)
+
+    # Calculate total from aggregated results
+    total = model.Usage()
+    for meta in by_model:
+        if not meta.usage:
+            continue
+        usage = meta.usage
+
+        # Set currency from first
+        if total.currency == "USD" and usage.currency:
+            total.currency = usage.currency
+
+        # Accumulate primary token fields (total_tokens is computed)
+        total.input_tokens += usage.input_tokens
+        total.cached_tokens += usage.cached_tokens
+        total.reasoning_tokens += usage.reasoning_tokens
+        total.output_tokens += usage.output_tokens
+
+        # Accumulate cost components (total_cost is computed)
+        if usage.input_cost is not None:
+            total.input_cost = (total.input_cost or 0.0) + usage.input_cost
+        if usage.output_cost is not None:
+            total.output_cost = (total.output_cost or 0.0) + usage.output_cost
+        if usage.cache_read_cost is not None:
+            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
+
+        # Keep the latest context_limit for computed context_usage_percent
+        if usage.context_limit is not None:
+            total.context_limit = usage.context_limit
+
+    return AggregatedUsage(total=total, by_model=by_model, task_count=task_count)
 
 
 def _format_tokens(tokens: int) -> str:
@@ -67,20 +85,42 @@ def _format_cost(cost: float | None, currency: str = "USD") -> str:
     return f"{symbol}{cost:.2f}"
 
 
-def format_status_content(usage: model.Usage) -> str:
-    """Format session status as comma-separated text."""
-    parts: list[str] = []
+def _format_model_usage_line(meta: model.TaskMetadata) -> str:
+    """Format a single model's usage as a line."""
+    model_label = meta.model_name
+    if meta.provider:
+        model_label = f"{meta.model_name} ({meta.provider})"
+
+    usage = meta.usage
+    if not usage:
+        return f"      {model_label}: no usage data"
+
+    cost_str = _format_cost(usage.total_cost, usage.currency)
+    return (
+        f"      {model_label}: "
+        f"{_format_tokens(usage.input_tokens)} input, "
+        f"{_format_tokens(usage.output_tokens)} output, "
+        f"{_format_tokens(usage.cached_tokens)} cache read, "
+        f"{_format_tokens(usage.reasoning_tokens)} thinking, "
+        f"({cost_str})"
+    )
+
+
+def format_status_content(aggregated: AggregatedUsage) -> str:
+    """Format session status with per-model breakdown."""
+    lines: list[str] = []
 
-    parts.append(f"Input: {_format_tokens(usage.input_tokens)}")
-    if usage.cached_tokens > 0:
-        parts.append(f"Cached: {_format_tokens(usage.cached_tokens)}")
-    parts.append(f"Output: {_format_tokens(usage.output_tokens)}")
-    parts.append(f"Total: {_format_tokens(usage.total_tokens)}")
+    # Total cost line
+    total_cost_str = _format_cost(aggregated.total.total_cost, aggregated.total.currency)
+    lines.append(f"Total cost: {total_cost_str}")
 
-    if usage.total_cost is not None:
-        parts.append(f"Cost: {_format_cost(usage.total_cost, usage.currency)}")
+    # Per-model breakdown
+    if aggregated.by_model:
+        lines.append("Usage by model:")
+        for stats in aggregated.by_model:
+            lines.append(_format_model_usage_line(stats))
 
-    return ", ".join(parts)
+    return "\n".join(lines)
 
 
 @register_command
@@ -97,20 +137,18 @@ class StatusCommand(CommandABC):
 
     async def run(self, raw: str, agent: Agent) -> CommandResult:
         session = agent.session
-        usage, task_count = accumulate_session_usage(session)
+        aggregated = accumulate_session_usage(session)
 
         event = events.DeveloperMessageEvent(
             session_id=session.id,
             item=model.DeveloperMessageItem(
-                content=format_status_content(usage),
+                content=format_status_content(aggregated),
                 command_output=model.CommandOutput(
                     command_name=self.name,
-                    ui_extra=model.ToolResultUIExtra(
-                        type=model.ToolResultUIExtraType.SESSION_STATUS,
-                        session_status=model.SessionStatusUIExtra(
-                            usage=usage,
-                            task_count=task_count,
-                        ),
+                    ui_extra=model.SessionStatusUIExtra(
+                        usage=aggregated.total,
+                        task_count=aggregated.task_count,
+                        by_model=aggregated.by_model,
                     ),
                 ),
             ),

klaude_code/core/agent.py

@@ -6,8 +6,8 @@ from typing import Protocol
 
 from klaude_code.core.prompt import get_system_prompt as load_system_prompt
 from klaude_code.core.reminders import Reminder, load_agent_reminders
-from klaude_code.core.task import TaskExecutionContext, TaskExecutor
-from klaude_code.core.tool import TodoContext, get_registry, load_agent_tools
+from klaude_code.core.task import SessionContext, TaskExecutionContext, TaskExecutor
+from klaude_code.core.tool import build_todo_context, get_registry, load_agent_tools
 from klaude_code.llm import LLMClientABC
 from klaude_code.protocol import events, llm_param, model, tools
 from klaude_code.protocol.model import UserInputPayload
@@ -76,11 +76,10 @@ class Agent:
         profile: AgentProfile,
     ):
         self.session: Session = session
-        self.profile: AgentProfile | None = None
-        # Active task executor, if any
+        self.profile: AgentProfile = profile
         self._current_task: TaskExecutor | None = None
-        # Ensure runtime configuration matches the active model on initialization
-        self.set_model_profile(profile)
+        if not self.session.model_name:
+            self.session.model_name = profile.llm_client.model_name
 
     def cancel(self) -> Iterable[events.Event]:
         """Handle agent cancellation and persist an interrupt marker and tool cancellations.
@@ -106,17 +105,17 @@ class Agent:
         )
 
     async def run_task(self, user_input: UserInputPayload) -> AsyncGenerator[events.Event, None]:
-        context = TaskExecutionContext(
+        session_ctx = SessionContext(
             session_id=self.session.id,
-            profile=self._require_profile(),
             get_conversation_history=lambda: self.session.conversation_history,
             append_history=self.session.append_history,
-            tool_registry=get_registry(),
             file_tracker=self.session.file_tracker,
-            todo_context=TodoContext(
-                get_todos=lambda: self.session.todos,
-                set_todos=lambda todos: setattr(self.session, "todos", todos),
-            ),
+            todo_context=build_todo_context(self.session),
+        )
+        context = TaskExecutionContext(
+            session_ctx=session_ctx,
+            profile=self.profile,
+            tool_registry=get_registry(),
             process_reminder=self._process_reminder,
             sub_agent_state=self.session.sub_agent_state,
         )
@@ -157,9 +156,4 @@ class Agent:
             self.session.model_name = profile.llm_client.model_name
 
     def get_llm_client(self) -> LLMClientABC:
-        return self._require_profile().llm_client
-
-    def _require_profile(self) -> AgentProfile:
-        if self.profile is None:
-            raise RuntimeError("Agent profile is not initialized")
-        return self.profile
+        return self.profile.llm_client

klaude_code/core/manager/sub_agent_manager.py

@@ -58,13 +58,17 @@ class SubAgentManager:
         try:
             # Not emit the subtask's user input since task tool call is already rendered
             result: str = ""
+            task_metadata: model.TaskMetadata | None = None
             sub_agent_input = model.UserInputPayload(text=state.sub_agent_prompt, images=None)
             async for event in child_agent.run_task(sub_agent_input):
                 # Capture TaskFinishEvent content for return
                 if isinstance(event, events.TaskFinishEvent):
                     result = event.task_result
+                # Capture TaskMetadataEvent for metadata propagation
+                elif isinstance(event, events.TaskMetadataEvent):
+                    task_metadata = event.metadata.main
                 await self.emit_event(event)
-            return SubAgentResult(task_result=result, session_id=child_session.id)
+            return SubAgentResult(task_result=result, session_id=child_session.id, task_metadata=task_metadata)
         except asyncio.CancelledError:
             # Propagate cancellation so tooling can treat it as user interrupt
             log_debug(

klaude_code/core/prompt.py

@@ -26,9 +26,34 @@ PROMPT_FILES: dict[str, str] = {
 
 
 @lru_cache(maxsize=None)
-def get_system_prompt(model_name: str, sub_agent_type: str | None = None) -> str:
-    """Get system prompt content for the given model and sub-agent type."""
+def _load_base_prompt(file_key: str) -> str:
+    """Load and cache the base prompt content from file."""
+    try:
+        prompt_path = PROMPT_FILES[file_key]
+    except KeyError as exc:
+        raise ValueError(f"Unknown prompt key: {file_key}") from exc
+
+    return files(__package__).joinpath(prompt_path).read_text(encoding="utf-8").strip()
 
+
+def _get_file_key(model_name: str, sub_agent_type: str | None) -> str:
+    """Determine which prompt file to use based on model and agent type."""
+    if sub_agent_type is not None:
+        return sub_agent_type
+
+    match model_name:
+        case "gpt-5.1-codex-max":
+            return "main_gpt_5_1_codex_max"
+        case name if "gpt-5" in name:
+            return "main_gpt_5_1"
+        case name if "gemini" in name:
+            return "main_gemini"
+        case _:
+            return "main_claude"
+
+
+def _build_env_info(model_name: str) -> str:
+    """Build environment info section with dynamic runtime values."""
     cwd = Path.cwd()
     today = datetime.datetime.now().strftime("%Y-%m-%d")
     is_git_repo = (cwd / ".git").exists()
@@ -38,30 +63,6 @@ def get_system_prompt(model_name: str, sub_agent_type: str | None = None) -> str
         if shutil.which(command) is not None:
             available_tools.append(f"{command}: {desc}")
 
-    if sub_agent_type is None:
-        match model_name:
-            case "gpt-5.1-codex-max":
-                file_key = "main_gpt_5_1_codex_max"
-            case name if "gpt-5" in name:
-                file_key = "main_gpt_5_1"
-            case name if "gemini" in name:
-                file_key = "main_gemini"
-            case _:
-                file_key = "main_claude"
-    else:
-        file_key = sub_agent_type
-
-    try:
-        prompt_path = PROMPT_FILES[file_key]
-    except KeyError as exc:
-        raise ValueError(f"Unknown prompt key: {file_key}") from exc
-
-    base_prompt = files(__package__).joinpath(prompt_path).read_text(encoding="utf-8").strip()
-
-    if model_name == "gpt-5.1-codex-max":
-        # Do not add env info for gpt-5.1-codex-max
-        return base_prompt
-
     env_lines: list[str] = [
         "",
         "",
@@ -80,6 +81,15 @@ def get_system_prompt(model_name: str, sub_agent_type: str | None = None) -> str
 
     env_lines.append("</env>")
 
-    env_info = "\n".join(env_lines)
+    return "\n".join(env_lines)
+
+
+def get_system_prompt(model_name: str, sub_agent_type: str | None = None) -> str:
+    """Get system prompt content for the given model and sub-agent type."""
+    file_key = _get_file_key(model_name, sub_agent_type)
+    base_prompt = _load_base_prompt(file_key)
+
+    if model_name == "gpt-5.1-codex-max":
+        return base_prompt
 
-    return base_prompt + env_info
+    return base_prompt + _build_env_info(model_name)

klaude_code/core/reminders.py

@@ -150,16 +150,16 @@ async def todo_not_used_recently_reminder(
         return None
 
     # Count non-todo tool calls since the last TodoWrite
-    other_tool_call_count_befor_last_todo = 0
+    other_tool_call_count_before_last_todo = 0
     for item in reversed(session.conversation_history):
         if isinstance(item, model.ToolCallItem):
             if item.name in (tools.TODO_WRITE, tools.UPDATE_PLAN):
                 break
-            other_tool_call_count_befor_last_todo += 1
-            if other_tool_call_count_befor_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD:
+            other_tool_call_count_before_last_todo += 1
+            if other_tool_call_count_before_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD:
                 break
 
-    not_used_recently = other_tool_call_count_befor_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD
+    not_used_recently = other_tool_call_count_before_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD
 
     if not not_used_recently:
         return None