klaude-code 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

klaude_code/protocol/model.py

@@ -5,7 +5,6 @@ from typing import Annotated, Any, Literal
 from pydantic import BaseModel, Field, computed_field
 
 from klaude_code.const import DEFAULT_MAX_TOKENS
-from klaude_code.protocol.commands import CommandName
 from klaude_code.protocol.tools import SubAgentType
 
 RoleType = Literal["system", "developer", "user", "assistant", "tool"]
@@ -272,12 +271,6 @@ ToolResultUIExtra = Annotated[
 ]
 
 
-class CommandOutput(BaseModel):
-    command_name: CommandName
-    ui_extra: ToolResultUIExtra | None = None
-    is_error: bool = False
-
-
 class MemoryFileLoaded(BaseModel):
     path: str
     mentioned_patterns: list[str] = Field(default_factory=list)
@@ -319,11 +312,6 @@ class SkillActivatedUIItem(BaseModel):
     name: str
 
 
-class CommandOutputUIItem(BaseModel):
-    type: Literal["command_output"] = "command_output"
-    output: CommandOutput
-
-
 type DeveloperUIItem = (
     MemoryLoadedUIItem
     | ExternalFileChangesUIItem
@@ -331,7 +319,6 @@ type DeveloperUIItem = (
     | AtFileOpsUIItem
     | UserImagesUIItem
     | SkillActivatedUIItem
-    | CommandOutputUIItem
 )
 
 
@@ -343,19 +330,6 @@ class DeveloperUIExtra(BaseModel):
     items: list[DeveloperUIItem] = Field(default_factory=_empty_developer_ui_items)
 
 
-def build_command_output_extra(
-    command_name: CommandName,
-    *,
-    ui_extra: ToolResultUIExtra | None = None,
-    is_error: bool = False,
-) -> DeveloperUIExtra:
-    return DeveloperUIExtra(
-        items=[
-            CommandOutputUIItem(output=CommandOutput(command_name=command_name, ui_extra=ui_extra, is_error=is_error))
-        ]
-    )
-
-
 class SubAgentState(BaseModel):
     sub_agent_type: SubAgentType
     sub_agent_desc: str

klaude_code/protocol/op.py

@@ -52,11 +52,6 @@ class RunAgentOperation(Operation):
     type: OperationType = OperationType.RUN_AGENT
     session_id: str
     input: UserInputPayload
-    # Frontends may choose to render the user message themselves (e.g. TUI) to support
-    # event-only commands; in that case the core should skip emitting the UserMessageEvent.
-    emit_user_message_event: bool = True
-    # Frontends may choose to run without persisting input (e.g. some interactive commands).
-    persist_user_input: bool = True
 
     async def execute(self, handler: OperationHandler) -> None:
         await handler.handle_run_agent(self)

klaude_code/session/session.py

@@ -237,7 +237,7 @@ class Session(BaseModel):
         Args:
             new_id: Optional ID for the forked session.
             until_index: If provided, only copy conversation history up to (but not including) this index.
-                         If None, copy all history.
+                         If -1, copy all history.
         """
 
         forked = Session.create(id=new_id, work_dir=self.work_dir)
@@ -250,7 +250,9 @@ class Session(BaseModel):
         forked.todos = [todo.model_copy(deep=True) for todo in self.todos]
 
         history_to_copy = (
-            self.conversation_history[:until_index] if until_index is not None else self.conversation_history
+            self.conversation_history[:until_index]
+            if (until_index is not None and until_index >= 0)
+            else self.conversation_history
         )
         items = [it.model_copy(deep=True) for it in history_to_copy]
         if items:

klaude_code/tui/command/clear_cmd.py

@@ -22,5 +22,4 @@ class ClearCommand(CommandABC):
 
         return CommandResult(
             operations=[op.ClearSessionOperation(session_id=agent.session.id)],
-            persist=False,
         )

klaude_code/tui/command/command_abc.py

@@ -37,14 +37,16 @@ class CommandResult(BaseModel):
     """Result of a command execution."""
 
     events: (
-        list[protocol_events.DeveloperMessageEvent | protocol_events.WelcomeEvent | protocol_events.ReplayHistoryEvent]
+        list[
+            protocol_events.CommandOutputEvent
+            | protocol_events.ErrorEvent
+            | protocol_events.WelcomeEvent
+            | protocol_events.ReplayHistoryEvent
+        ]
         | None
     ) = None  # List of UI events to display immediately
     operations: list[op.Operation] | None = None
 
-    # Persistence controls: some slash commands are UI/control actions and should not be written to session history.
-    persist: bool = True
-
 
 class CommandABC(ABC):
     """Abstract base class for slash commands."""

klaude_code/tui/command/copy_cmd.py

@@ -1,4 +1,4 @@
-from klaude_code.protocol import commands, events, message, model
+from klaude_code.protocol import commands, events, message
 from klaude_code.tui.input.clipboard import copy_to_clipboard
 
 from .command_abc import Agent, CommandABC, CommandResult
@@ -20,10 +20,10 @@ class CopyCommand(CommandABC):
 
         last = _get_last_assistant_text(agent.session.conversation_history)
         if not last:
-            return _developer_message(agent, "(no assistant message to copy)", self.name)
+            return _command_output(agent, "(no assistant message to copy)", self.name, is_error=True)
 
         copy_to_clipboard(last)
-        return _developer_message(agent, "Copied last assistant message to clipboard.", self.name)
+        return _command_output(agent, "Copied last assistant message to clipboard.", self.name)
 
 
 def _get_last_assistant_text(history: list[message.HistoryEvent]) -> str:
@@ -37,16 +37,16 @@ def _get_last_assistant_text(history: list[message.HistoryEvent]) -> str:
     return ""
 
 
-def _developer_message(agent: Agent, content: str, command_name: commands.CommandName) -> CommandResult:
+def _command_output(
+    agent: Agent, content: str, command_name: commands.CommandName, *, is_error: bool = False
+) -> CommandResult:
     return CommandResult(
         events=[
-            events.DeveloperMessageEvent(
+            events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(content),
-                    ui_extra=model.build_command_output_extra(command_name),
-                ),
+                command_name=command_name,
+                content=content,
+                is_error=is_error,
             )
         ],
-        persist=False,
     )

klaude_code/tui/command/debug_cmd.py

@@ -1,5 +1,5 @@
 from klaude_code.log import DebugType, get_current_log_file, is_debug_enabled, set_debug_logging
-from klaude_code.protocol import commands, events, message, model
+from klaude_code.protocol import commands, events, message
 
 from .command_abc import Agent, CommandABC, CommandResult
 
@@ -52,7 +52,7 @@ class DebugCommand(CommandABC):
         # /debug (no args) - enable debug
         if not raw:
             set_debug_logging(True, write_to_file=True)
-            return self._message_result(agent, _format_status())
+            return self._command_output(agent, _format_status())
 
         # /debug <filters> - enable with filters
         try:
@@ -60,21 +60,22 @@ class DebugCommand(CommandABC):
             if filters:
                 set_debug_logging(True, write_to_file=True, filters=filters)
                 filter_names = ", ".join(sorted(dt.value for dt in filters))
-                return self._message_result(agent, f"Filters: {filter_names}\n{_format_status()}")
+                return self._command_output(agent, f"Filters: {filter_names}\n{_format_status()}")
         except ValueError:
             pass
 
-        return self._message_result(agent, f"Invalid filter: {raw}\nValid: {', '.join(dt.value for dt in DebugType)}")
+        return self._command_output(
+            agent, f"Invalid filter: {raw}\nValid: {', '.join(dt.value for dt in DebugType)}", is_error=True
+        )
 
-    def _message_result(self, agent: "Agent", content: str) -> CommandResult:
+    def _command_output(self, agent: "Agent", content: str, *, is_error: bool = False) -> CommandResult:
         return CommandResult(
             events=[
-                events.DeveloperMessageEvent(
+                events.CommandOutputEvent(
                     session_id=agent.session.id,
-                    item=message.DeveloperMessage(
-                        parts=message.text_parts_from_str(content),
-                        ui_extra=model.build_command_output_extra(self.name),
-                    ),
+                    command_name=self.name,
+                    content=content,
+                    is_error=is_error,
                 )
             ]
         )

klaude_code/tui/command/export_online_cmd.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from rich.console import Console
 from rich.text import Text
 
-from klaude_code.protocol import commands, events, message, model
+from klaude_code.protocol import commands, events, message
 from klaude_code.session.export import build_export_html
 
 from .command_abc import Agent, CommandABC, CommandResult
@@ -39,54 +39,49 @@ class ExportOnlineCommand(CommandABC):
         # Check if npx or surge is available
         surge_cmd = self._get_surge_command()
         if not surge_cmd:
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str("surge.sh CLI not found. Install with: npm install -g surge"),
-                    ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                ),
+                command_name=self.name,
+                content="surge.sh CLI not found. Install with: npm install -g surge",
+                is_error=True,
             )
             return CommandResult(events=[event])
 
         try:
             console = Console()
             # Check login status inside status context since npx surge whoami can be slow
-            with console.status(Text("Checking surge.sh login status…", style="dim"), spinner_style="dim"):
+            with console.status(Text("Checking surge.sh login status...", style="dim"), spinner_style="dim"):
                 logged_in = self._is_surge_logged_in(surge_cmd)
 
             if not logged_in:
                 login_cmd = " ".join([*surge_cmd, "login"])
-                event = events.DeveloperMessageEvent(
+                event = events.CommandOutputEvent(
                     session_id=agent.session.id,
-                    item=message.DeveloperMessage(
-                        parts=message.text_parts_from_str(f"Not logged in to surge.sh. Please run: {login_cmd}"),
-                        ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                    ),
+                    command_name=self.name,
+                    content=f"Not logged in to surge.sh. Please run: {login_cmd}",
+                    is_error=True,
                 )
                 return CommandResult(events=[event])
 
-            with console.status(Text("Deploying to surge.sh…", style="dim"), spinner_style="dim"):
+            with console.status(Text("Deploying to surge.sh...", style="dim"), spinner_style="dim"):
                 html_doc = self._build_html(agent)
                 domain = self._generate_domain()
                 url = self._deploy_to_surge(surge_cmd, html_doc, domain)
 
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(f"Session deployed to: {url}"),
-                    ui_extra=model.build_command_output_extra(self.name),
-                ),
+                command_name=self.name,
+                content=f"Session deployed to: {url}",
             )
             return CommandResult(events=[event])
         except Exception as exc:
             import traceback
 
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(f"Failed to deploy session: {exc}\n{traceback.format_exc()}"),
-                    ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                ),
+                command_name=self.name,
+                content=f"Failed to deploy session: {exc}\n{traceback.format_exc()}",
+                is_error=True,
             )
             return CommandResult(events=[event])
 

klaude_code/tui/command/fork_session_cmd.py

@@ -31,7 +31,7 @@ FORK_SELECT_STYLE = Style(
 class ForkPoint:
     """A fork point in conversation history."""
 
-    history_index: int | None  # None means fork entire conversation
+    history_index: int  # -1 means fork entire conversation
     user_message: str
     tool_call_stats: dict[str, int]  # tool_name -> count
     last_assistant_summary: str
@@ -94,7 +94,7 @@ def _build_fork_points(conversation_history: list[message.HistoryEvent]) -> list
     if user_indices:
         fork_points.append(
             ForkPoint(
-                history_index=None,  # None means fork entire conversation
+                history_index=-1,  # None means fork entire conversation
                 user_message="",  # No specific message, this represents the end
                 tool_call_stats={},
                 last_assistant_summary="",
@@ -104,9 +104,9 @@ def _build_fork_points(conversation_history: list[message.HistoryEvent]) -> list
     return fork_points
 
 
-def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | None]]:
+def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int]]:
     """Build SelectItem list from fork points."""
-    items: list[SelectItem[int | None]] = []
+    items: list[SelectItem[int]] = []
 
     for i, fp in enumerate(fork_points):
         is_first = i == 0
@@ -116,8 +116,8 @@ def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | N
         title_parts: list[tuple[str, str]] = []
 
         # First line: separator (with special markers for first/last fork points)
-        if is_first and not is_last:
-            title_parts.append(("class:separator", "----- fork from here (empty session) -----\n\n"))
+        if is_first:
+            pass
         elif is_last:
             title_parts.append(("class:separator", "----- fork from here (entire session) -----\n\n"))
         else:
@@ -150,17 +150,16 @@ def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | N
     return items
 
 
-def _select_fork_point_sync(fork_points: list[ForkPoint]) -> int | None | Literal["cancelled"]:
+def _select_fork_point_sync(fork_points: list[ForkPoint]) -> int | Literal["cancelled"]:
     """Interactive fork point selection (sync version for asyncio.to_thread).
 
     Returns:
-        - int: history index to fork at (exclusive)
-        - None: fork entire conversation
+        - int: history index to fork at (exclusive), -1 means fork entire conversation
         - "cancelled": user cancelled selection
     """
     items = _build_select_items(fork_points)
     if not items:
-        return None
+        return -1
 
     # Default to the last option (fork entire conversation)
     last_value = items[-1].value
@@ -204,14 +203,13 @@ class ForkSessionCommand(CommandABC):
         del user_input  # unused
 
         if agent.session.messages_count == 0:
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str("(no messages to fork)"),
-                    ui_extra=model.build_command_output_extra(self.name),
-                ),
+                command_name=self.name,
+                content="(no messages to fork)",
+                is_error=True,
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
 
         # Build fork points from conversation history
         fork_points = _build_fork_points(agent.session.conversation_history)
@@ -224,51 +222,49 @@ class ForkSessionCommand(CommandABC):
             resume_cmd = f"klaude --resume-by-id {new_session.id}"
             copy_to_clipboard(resume_cmd)
 
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(f"Session forked successfully. New session id: {new_session.id}"),
-                    ui_extra=model.build_command_output_extra(
-                        self.name,
-                        ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
-                    ),
-                ),
+                command_name=self.name,
+                content=f"Session forked successfully. New session id: {new_session.id}",
+                ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
 
         # Interactive selection
         selected = await asyncio.to_thread(_select_fork_point_sync, fork_points)
 
         if selected == "cancelled":
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str("(fork cancelled)"),
-                    ui_extra=model.build_command_output_extra(self.name),
-                ),
+                command_name=self.name,
+                content="(fork cancelled)",
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
+
+        # First option (empty session) is just for UI display, not a valid fork point
+        if selected == fork_points[0].history_index:
+            event = events.CommandOutputEvent(
+                session_id=agent.session.id,
+                command_name=self.name,
+                content="(cannot fork to empty session)",
+                is_error=True,
+            )
+            return CommandResult(events=[event])
 
         # Perform the fork
         new_session = agent.session.fork(until_index=selected)
         await new_session.wait_for_flush()
 
         # Build result message
-        fork_description = "entire conversation" if selected is None else f"up to message index {selected}"
+        fork_description = "entire conversation" if selected == -1 else f"up to message index {selected}"
 
         resume_cmd = f"klaude --resume-by-id {new_session.id}"
         copy_to_clipboard(resume_cmd)
 
-        event = events.DeveloperMessageEvent(
+        event = events.CommandOutputEvent(
             session_id=agent.session.id,
-            item=message.DeveloperMessage(
-                parts=message.text_parts_from_str(
-                    f"Session forked ({fork_description}). New session id: {new_session.id}"
-                ),
-                ui_extra=model.build_command_output_extra(
-                    self.name,
-                    ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
-                ),
-            ),
+            command_name=self.name,
+            content=f"Session forked ({fork_description}). New session id: {new_session.id}",
+            ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
         )
-        return CommandResult(events=[event], persist=False)
+        return CommandResult(events=[event])

klaude_code/tui/command/model_cmd.py

@@ -1,9 +1,9 @@
 import asyncio
 
-from klaude_code.protocol import commands, events, message, model, op
+from klaude_code.protocol import commands, events, message, op
 
 from .command_abc import Agent, CommandABC, CommandResult
-from .model_select import ModelSelectStatus, select_model_interactive
+from .model_picker import ModelSelectStatus, select_model_interactive
 
 
 class ModelCommand(CommandABC):
@@ -37,12 +37,10 @@ class ModelCommand(CommandABC):
         if selected_model is None or selected_model == current_model:
             return CommandResult(
                 events=[
-                    events.DeveloperMessageEvent(
+                    events.CommandOutputEvent(
                         session_id=agent.session.id,
-                        item=message.DeveloperMessage(
-                            parts=message.text_parts_from_str("(no change)"),
-                            ui_extra=model.build_command_output_extra(self.name),
-                        ),
+                        command_name=self.name,
+                        content="(no change)",
                     )
                 ]
             )

klaude_code/tui/command/{model_select.py → model_picker.py}

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 from enum import Enum
 
 from klaude_code.config.config import load_config
-from klaude_code.config.select_model import match_model_from_config
+from klaude_code.config.model_matcher import match_model_from_config
 from klaude_code.log import log
 
 
@@ -35,7 +35,7 @@ def select_model_interactive(
     This function combines matching logic with interactive UI selection.
     For CLI usage.
 
-    If keywords is provided, preferred is ignored and the model list is pre-filtered by model_params.model.
+    If keywords is provided, preferred is ignored and the model list is pre-filtered by model_id.
 
     If preferred is provided:
     - Exact match: return immediately
@@ -54,9 +54,7 @@ def select_model_interactive(
     if keywords:
         keywords_lower = [k.lower() for k in keywords]
         filtered_models = [
-            m
-            for m in result.filtered_models
-            if any(kw in (m.model_params.model or "").lower() for kw in keywords_lower)
+            m for m in result.filtered_models if any(kw in (m.model_id or "").lower() for kw in keywords_lower)
         ]
         if not filtered_models:
             return ModelSelectResult(status=ModelSelectStatus.NO_MATCH)

klaude_code/tui/command/refresh_cmd.py

@@ -38,5 +38,4 @@ class RefreshTerminalCommand(CommandABC):
                     is_load=False,
                 ),
             ],
-            persist=False,
         )

klaude_code/tui/command/registry.py

@@ -2,7 +2,7 @@ from importlib.resources import files
 from typing import TYPE_CHECKING
 
 from klaude_code.log import log_debug
-from klaude_code.protocol import commands, events, message, model, op
+from klaude_code.protocol import commands, events, message, op
 
 from .command_abc import Agent, CommandResult
 from .prompt_command import PromptCommand
@@ -179,30 +179,24 @@ async def dispatch_command(user_input: message.UserInputPayload, agent: Agent, *
             result.operations = ops
         return result
     except Exception as e:
-        command_output = (
-            model.CommandOutput(command_name=command_identifier, is_error=True)
-            if isinstance(command_identifier, commands.CommandName)
-            else None
-        )
-        ui_extra = (
-            model.build_command_output_extra(
-                command_output.command_name,
-                ui_extra=command_output.ui_extra,
-                is_error=command_output.is_error,
+        error_content = f"Command {command_identifier} error: [{e.__class__.__name__}] {e!s}"
+        if isinstance(command_identifier, commands.CommandName):
+            return CommandResult(
+                events=[
+                    events.CommandOutputEvent(
+                        session_id=agent.session.id,
+                        command_name=command_identifier,
+                        content=error_content,
+                        is_error=True,
+                    )
+                ]
             )
-            if command_output is not None
-            else None
-        )
         return CommandResult(
             events=[
-                events.DeveloperMessageEvent(
+                events.ErrorEvent(
                     session_id=agent.session.id,
-                    item=message.DeveloperMessage(
-                        parts=message.text_parts_from_str(
-                            f"Command {command_identifier} error: [{e.__class__.__name__}] {e!s}"
-                        ),
-                        ui_extra=ui_extra,
-                    ),
+                    error_message=error_content,
+                    can_retry=False,
                 )
             ]
         )

klaude_code/tui/command/resume_cmd.py

@@ -3,7 +3,7 @@ import asyncio
 from prompt_toolkit.styles import Style
 
 from klaude_code.log import log
-from klaude_code.protocol import commands, events, message, model, op
+from klaude_code.protocol import commands, events, message, op
 from klaude_code.session.selector import build_session_select_options, format_user_messages_display
 from klaude_code.tui.terminal.selector import SelectItem, select_one
 
@@ -87,29 +87,23 @@ class ResumeCommand(CommandABC):
         del user_input  # unused
 
         if agent.session.messages_count > 0:
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str(
-                        "Cannot resume: current session already has messages. Use `klaude -r` to start a new instance with session selection."
-                    ),
-                    ui_extra=model.build_command_output_extra(self.name, is_error=True),
-                ),
+                command_name=self.name,
+                content="Cannot resume: current session already has messages. Use `klaude -r` to start a new instance with session selection.",
+                is_error=True,
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
 
         selected_session_id = await asyncio.to_thread(select_session_sync)
         if selected_session_id is None:
-            event = events.DeveloperMessageEvent(
+            event = events.CommandOutputEvent(
                 session_id=agent.session.id,
-                item=message.DeveloperMessage(
-                    parts=message.text_parts_from_str("(no session selected)"),
-                    ui_extra=model.build_command_output_extra(self.name),
-                ),
+                command_name=self.name,
+                content="(no session selected)",
             )
-            return CommandResult(events=[event], persist=False)
+            return CommandResult(events=[event])
 
         return CommandResult(
             operations=[op.ResumeSessionOperation(target_session_id=selected_session_id)],
-            persist=False,
         )

klaude_code/tui/command/status_cmd.py

@@ -138,19 +138,15 @@ class StatusCommand(CommandABC):
         session = agent.session
         aggregated = accumulate_session_usage(session)
 
-        event = events.DeveloperMessageEvent(
+        event = events.CommandOutputEvent(
             session_id=session.id,
-            item=message.DeveloperMessage(
-                parts=message.text_parts_from_str(format_status_content(aggregated)),
-                ui_extra=model.build_command_output_extra(
-                    self.name,
-                    ui_extra=model.SessionStatusUIExtra(
-                        usage=aggregated.total,
-                        task_count=aggregated.task_count,
-                        by_model=aggregated.by_model,
-                    ),
-                ),
+            command_name=self.name,
+            content=format_status_content(aggregated),
+            ui_extra=model.SessionStatusUIExtra(
+                usage=aggregated.total,
+                task_count=aggregated.task_count,
+                by_model=aggregated.by_model,
             ),
         )
 
-        return CommandResult(events=[event], persist=False)
+        return CommandResult(events=[event])