klaude-code 2.1.0__py3-none-any.whl → 2.2.0__py3-none-any.whl

klaude_code/core/tool/shell/command_safety.py

@@ -1,5 +1,4 @@
 import os
-import re
 import shlex
 
 
@@ -11,76 +10,6 @@ class SafetyCheckResult:
         self.error_msg = error_msg
 
 
-def _is_valid_sed_n_arg(s: str | None) -> bool:
-    if not s:
-        return False
-    # Matches: Np or M,Np where M,N are positive integers
-    return bool(re.fullmatch(r"\d+(,\d+)?p", s))
-
-
-def _is_safe_awk_program(program: str) -> SafetyCheckResult:
-    lowered = program.lower()
-
-    if "`" in program:
-        return SafetyCheckResult(False, "awk: backticks not allowed in program")
-    if "$(" in program:
-        return SafetyCheckResult(False, "awk: command substitution not allowed in program")
-    if "|&" in program:
-        return SafetyCheckResult(False, "awk: background pipeline not allowed in program")
-
-    if "system(" in lowered:
-        return SafetyCheckResult(False, "awk: system() call not allowed in program")
-
-    if re.search(r"(?<![|&>])\bprint\s*\|", program, re.IGNORECASE):
-        return SafetyCheckResult(False, "awk: piping output to external command not allowed")
-    if re.search(r"\bprintf\s*\|", program, re.IGNORECASE):
-        return SafetyCheckResult(False, "awk: piping output to external command not allowed")
-
-    return SafetyCheckResult(True)
-
-
-def _is_safe_awk_argv(argv: list[str]) -> SafetyCheckResult:
-    if len(argv) < 2:
-        return SafetyCheckResult(False, "awk: Missing program")
-
-    program: str | None = None
-
-    i = 1
-    while i < len(argv):
-        arg = argv[i]
-
-        if arg in {"-f", "--file", "--source"} or arg.startswith("-f"):
-            return SafetyCheckResult(False, "awk: -f/--file not allowed")
-
-        if arg in {"-e", "--exec"}:
-            if i + 1 >= len(argv):
-                return SafetyCheckResult(False, "awk: Missing program for -e")
-            script = argv[i + 1]
-            program_check = _is_safe_awk_program(script)
-            if not program_check.is_safe:
-                return program_check
-            if program is None:
-                program = script
-            i += 2
-            continue
-
-        if arg.startswith("-"):
-            i += 1
-            continue
-
-        if program is None:
-            program_check = _is_safe_awk_program(arg)
-            if not program_check.is_safe:
-                return program_check
-            program = arg
-        i += 1
-
-    if program is None:
-        return SafetyCheckResult(False, "awk: Missing program")
-
-    return SafetyCheckResult(True)
-
-
 def _is_safe_rm_argv(argv: list[str]) -> SafetyCheckResult:
     """Check safety of rm command arguments."""
     # Enforce strict safety rules for rm operands
@@ -217,112 +146,12 @@ def _is_safe_argv(argv: list[str]) -> SafetyCheckResult:
 
     cmd0 = argv[0]
 
-    # if _has_shell_redirection(argv):
-    #     return SafetyCheckResult(False, "Shell redirection and pipelines are not allowed in single commands")
-
-    # Special handling for rm to prevent dangerous operations
     if cmd0 == "rm":
         return _is_safe_rm_argv(argv)
 
-    # Special handling for trash to prevent dangerous operations
     if cmd0 == "trash":
         return _is_safe_trash_argv(argv)
 
-    if cmd0 == "find":
-        unsafe_opts = {
-            "-exec": "command execution",
-            "-execdir": "command execution",
-            "-ok": "interactive command execution",
-            "-okdir": "interactive command execution",
-            "-delete": "file deletion",
-            "-fls": "file output",
-            "-fprint": "file output",
-            "-fprint0": "file output",
-            "-fprintf": "formatted file output",
-        }
-        for arg in argv[1:]:
-            if arg in unsafe_opts:
-                return SafetyCheckResult(False, f"find: {unsafe_opts[arg]} option '{arg}' not allowed")
-        return SafetyCheckResult(True)
-
-    if cmd0 == "git":
-        sub = argv[1] if len(argv) > 1 else None
-        if not sub:
-            return SafetyCheckResult(False, "git: Missing subcommand")
-
-        # Allow most local git operations, but block remote operations
-        allowed_git_cmds = {
-            "add",
-            "branch",
-            "checkout",
-            "commit",
-            "config",
-            "diff",
-            "fetch",
-            "init",
-            "log",
-            "merge",
-            "mv",
-            "rebase",
-            "reset",
-            "restore",
-            "revert",
-            "rm",
-            "show",
-            "stash",
-            "status",
-            "switch",
-            "tag",
-            "clone",
-            "worktree",
-            "push",
-            "pull",
-            "remote",
-        }
-        if sub not in allowed_git_cmds:
-            return SafetyCheckResult(False, f"git: Subcommand '{sub}' not in allow list")
-        return SafetyCheckResult(True)
-
-    # Build tools and linters - allow all subcommands
-    if cmd0 in {
-        "cargo",
-        "uv",
-        "go",
-        "ruff",
-        "pyright",
-        "make",
-        "npm",
-        "pnpm",
-        "bun",
-    }:
-        return SafetyCheckResult(True)
-
-    if cmd0 == "sed":
-        # Allow sed -n patterns (line printing)
-        if len(argv) >= 3 and argv[1] == "-n" and _is_valid_sed_n_arg(argv[2]):
-            return SafetyCheckResult(True)
-        # Allow simple text replacement: sed 's/old/new/g' file
-        # or sed -i 's/old/new/g' file for in-place editing
-        if len(argv) >= 3:
-            # Find the sed script argument (usually starts with 's/')
-            for arg in argv[1:]:
-                if arg.startswith("s/") or arg.startswith("s|"):
-                    # Basic safety check: no command execution in replacement
-                    if ";" in arg:
-                        return SafetyCheckResult(False, f"sed: Command separator ';' not allowed in '{arg}'")
-                    if "`" in arg:
-                        return SafetyCheckResult(False, f"sed: Backticks not allowed in '{arg}'")
-                    if "$(" in arg:
-                        return SafetyCheckResult(False, f"sed: Command substitution not allowed in '{arg}'")
-                    return SafetyCheckResult(True)
-        return SafetyCheckResult(
-            False,
-            "sed: Only text replacement (s/old/new/) or line printing (-n 'Np') is allowed",
-        )
-
-    if cmd0 == "awk":
-        return _is_safe_awk_argv(argv)
-
     # Default allow when command is not explicitly restricted
     return SafetyCheckResult(True)
 
@@ -330,30 +159,16 @@ def _is_safe_argv(argv: list[str]) -> SafetyCheckResult:
 def is_safe_command(command: str) -> SafetyCheckResult:
     """Determine if a command is safe enough to run.
 
-    The check is intentionally lightweight: it blocks only a small set of
-    obviously dangerous patterns (rm/trash/git remotes, unsafe sed/awk,
-    find -exec/-delete, etc.) and otherwise lets the real shell surface
-    syntax errors (for example, unmatched quotes in complex multiline
-    scripts).
+    Only rm and trash commands are checked for safety. All other commands
+    are allowed by default.
     """
-
-    # Try to parse into an argv-style list first. If this fails (e.g. due
-    # to unterminated quotes in a complex heredoc), treat the command as
-    # safe here and let bash itself perform syntax checking instead of
-    # blocking execution pre-emptively.
     try:
         argv = shlex.split(command, posix=True)
     except ValueError:
-        # If we cannot reliably parse the command (e.g. due to unterminated
-        # quotes in a complex heredoc), treat it as safe here and let the
-        # real shell surface any syntax errors instead of blocking execution
-        # pre-emptively.
+        # If we cannot reliably parse the command, treat it as safe here
+        # and let the real shell surface any syntax errors
         return SafetyCheckResult(True)
 
-    # All further safety checks are done directly on the parsed argv via
-    # _is_safe_argv. We intentionally avoid trying to re-interpret complex
-    # shell sequences here and rely on the real shell to handle syntax.
-
     if not argv:
         return SafetyCheckResult(False, "Empty command")
 

klaude_code/core/turn.py

@@ -69,7 +69,6 @@ def build_events_from_tool_executor_event(session_id: str, event: ToolExecutorEv
                 )
             )
         case ToolExecutionResult(tool_call=tool_call, tool_result=tool_result, is_last_in_turn=is_last_in_turn):
-            status = "success" if tool_result.status == "success" else "error"
             ui_events.append(
                 events.ToolResultEvent(
                     session_id=session_id,
@@ -78,13 +77,11 @@ def build_events_from_tool_executor_event(session_id: str, event: ToolExecutorEv
                     tool_name=tool_call.tool_name,
                     result=tool_result.output_text,
                     ui_extra=tool_result.ui_extra,
-                    status=status,
+                    status=tool_result.status,
                     task_metadata=tool_result.task_metadata,
                     is_last_in_turn=is_last_in_turn,
                 )
             )
-            if tool_result.status == "aborted":
-                ui_events.append(events.InterruptEvent(session_id=session_id))
         case ToolExecutionTodoChange(todos=todos):
             ui_events.append(
                 events.TodoChangeEvent(
@@ -351,7 +348,7 @@ class TurnExecutor:
                         style="red",
                         debug_type=DebugType.RESPONSE,
                     )
-                case message.ToolCallStartItem() as msg:
+                case message.ToolCallStartDelta() as msg:
                     if thinking_active:
                         thinking_active = False
                         yield events.ThinkingEndEvent(

klaude_code/llm/anthropic/client.py

@@ -169,7 +169,7 @@ async def parse_anthropic_stream(
                 match event.content_block:
                     case BetaToolUseBlock() as block:
                         metadata_tracker.record_token()
-                        yield message.ToolCallStartItem(
+                        yield message.ToolCallStartDelta(
                             response_id=response_id,
                             call_id=block.id,
                             name=block.name,

klaude_code/llm/google/client.py

@@ -242,7 +242,7 @@ async def parse_google_stream(
 
             if call_id not in started_tool_items:
                 started_tool_items.add(call_id)
-                yield message.ToolCallStartItem(response_id=response_id, call_id=call_id, name=name)
+                yield message.ToolCallStartDelta(response_id=response_id, call_id=call_id, name=name)
 
             args_obj = getattr(function_call, "args", None)
             if args_obj is not None:

klaude_code/llm/openai_compatible/stream.py

@@ -303,7 +303,7 @@ async def parse_chat_completions_stream(
                 for tc in tool_calls:
                     if tc.index not in state.emitted_tool_start_indices and tc.function and tc.function.name:
                         state.emitted_tool_start_indices.add(tc.index)
-                        yield message.ToolCallStartItem(
+                        yield message.ToolCallStartDelta(
                             response_id=state.response_id,
                             call_id=tc.id or "",
                             name=tc.function.name,

klaude_code/llm/responses/client.py

@@ -145,7 +145,7 @@ async def parse_responses_stream(
                 case responses.ResponseOutputItemAddedEvent() as event:
                     if isinstance(event.item, responses.ResponseFunctionToolCall):
                         metadata_tracker.record_token()
-                        yield message.ToolCallStartItem(
+                        yield message.ToolCallStartDelta(
                             response_id=response_id,
                             call_id=event.item.call_id,
                             name=event.item.name,

klaude_code/protocol/commands.py

@@ -28,6 +28,7 @@ class CommandName(str, Enum):
     THINKING = "thinking"
     FORK_SESSION = "fork-session"
     RESUME = "resume"
+    COPY = "copy"
     # PLAN and DOC are dynamically registered now, but kept here if needed for reference
     # or we can remove them if no code explicitly imports them.
     # PLAN = "plan"

klaude_code/protocol/events/tools.py

@@ -18,6 +18,10 @@ class ToolResultEvent(ResponseEvent):
     tool_name: str
     result: str
     ui_extra: model.ToolResultUIExtra | None = None
-    status: Literal["success", "error"]
+    status: Literal["success", "error", "aborted"]
     task_metadata: model.TaskMetadata | None = None
     is_last_in_turn: bool = True
+
+    @property
+    def is_error(self) -> bool:
+        return self.status in ("error", "aborted")

klaude_code/protocol/message.py

@@ -25,7 +25,7 @@ from klaude_code.protocol.model import (
 # Stream items
 
 
-class ToolCallStartItem(BaseModel):
+class ToolCallStartDelta(BaseModel):
     """Transient streaming signal when LLM starts a tool call.
 
     This is NOT persisted to conversation history. Used only for
@@ -175,7 +175,7 @@ Message = SystemMessage | DeveloperMessage | UserMessage | AssistantMessage | To
 
 HistoryEvent = Message | StreamErrorItem | TaskMetadataItem
 
-StreamItem = AssistantTextDelta | AssistantImageDelta | ThinkingTextDelta | ToolCallStartItem
+StreamItem = AssistantTextDelta | AssistantImageDelta | ThinkingTextDelta | ToolCallStartDelta
 
 LLMStreamItem = HistoryEvent | StreamItem
 

klaude_code/protocol/tools.py

@@ -6,7 +6,6 @@ READ = "Read"
 WRITE = "Write"
 TODO_WRITE = "TodoWrite"
 UPDATE_PLAN = "update_plan"
-SKILL = "Skill"
 MERMAID = "Mermaid"
 WEB_FETCH = "WebFetch"
 WEB_SEARCH = "WebSearch"

klaude_code/session/session.py

@@ -350,8 +350,6 @@ class Session(BaseModel):
                         is_last_in_turn=is_last_in_turn,
                     )
                     yield from self._iter_sub_agent_history(tr, seen_sub_agent_sessions)
-                    if tr.status == "aborted":
-                        yield events.InterruptEvent(session_id=self.id)
                 case message.UserMessage() as um:
                     images = [part for part in um.parts if isinstance(part, message.ImageURLPart)]
                     yield events.UserMessageEvent(

klaude_code/skill/loader.py

@@ -1,4 +1,3 @@
-import re
 from dataclasses import dataclass
 from pathlib import Path
 from typing import ClassVar
@@ -14,12 +13,12 @@ class Skill:
 
     name: str  # Skill identifier (lowercase-hyphen)
     description: str  # What the skill does and when to use it
-    content: str  # Full markdown instructions
-    location: str  # Skill location: 'system', 'user', or 'project'
+    location: str  # Skill source: 'system', 'user', or 'project'
+    skill_path: Path
+    base_dir: Path
     license: str | None = None
     allowed_tools: list[str] | None = None
     metadata: dict[str, str] | None = None
-    skill_path: Path | None = None
 
     @property
     def short_description(self) -> str:
@@ -31,17 +30,6 @@ class Skill:
             return self.metadata["short-description"]
         return self.description
 
-    def to_prompt(self) -> str:
-        """Convert skill to prompt format for agent consumption"""
-        return f"""# Skill: {self.name}
-
-{self.description}
-
----
-
-{self.content}
-"""
-
 
 class SkillLoader:
     """Load and manage Claude Skills from SKILL.md files"""
@@ -79,7 +67,6 @@ class SkillLoader:
 
             # Parse YAML frontmatter
             frontmatter: dict[str, object] = {}
-            markdown_content = content
 
             if content.startswith("---"):
                 parts = content.split("---", 2)
@@ -87,7 +74,6 @@ class SkillLoader:
                     loaded: object = yaml.safe_load(parts[1])
                     if isinstance(loaded, dict):
                         frontmatter = dict(loaded)  # type: ignore[arg-type]
-                    markdown_content = parts[2].strip()
 
             # Extract skill metadata
             name = str(frontmatter.get("name", ""))
@@ -96,10 +82,6 @@ class SkillLoader:
             if not name or not description:
                 return None
 
-            # Process relative paths in content
-            skill_dir = skill_path.parent
-            processed_content = self._process_skill_paths(markdown_content, skill_dir)
-
             # Create Skill object
             license_val = frontmatter.get("license")
             allowed_tools_val = frontmatter.get("allowed-tools")
@@ -118,12 +100,12 @@ class SkillLoader:
             skill = Skill(
                 name=name,
                 description=description,
-                content=processed_content,
                 location=location,
                 license=str(license_val) if license_val is not None else None,
                 allowed_tools=allowed_tools,
                 metadata=metadata,
-                skill_path=skill_path,
+                skill_path=skill_path.resolve(),
+                base_dir=skill_path.parent.resolve(),
             )
 
             return skill
@@ -144,6 +126,15 @@ class SkillLoader:
             List of successfully loaded Skill objects
         """
         skills: list[Skill] = []
+        priority = {"system": 0, "user": 1, "project": 2}
+
+        def register(skill: Skill) -> None:
+            existing = self.loaded_skills.get(skill.name)
+            if existing is None:
+                self.loaded_skills[skill.name] = skill
+                return
+            if priority.get(skill.location, -1) >= priority.get(existing.location, -1):
+                self.loaded_skills[skill.name] = skill
 
         # Load system-level skills first (lowest priority, can be overridden)
         system_dir = self.SYSTEM_SKILLS_DIR.expanduser()
@@ -152,7 +143,7 @@ class SkillLoader:
                 skill = self.load_skill(skill_file, location="system")
                 if skill:
                     skills.append(skill)
-                    self.loaded_skills[skill.name] = skill
+                    register(skill)
 
         # Load user-level skills (override system skills if same name)
         for user_dir in self.USER_SKILLS_DIRS:
@@ -165,7 +156,7 @@ class SkillLoader:
                     skill = self.load_skill(skill_file, location="user")
                     if skill:
                         skills.append(skill)
-                        self.loaded_skills[skill.name] = skill
+                        register(skill)
 
         # Load project-level skills (override user skills if same name)
         project_dir = self.PROJECT_SKILLS_DIR.resolve()
@@ -174,13 +165,14 @@ class SkillLoader:
                 skill = self.load_skill(skill_file, location="project")
                 if skill:
                     skills.append(skill)
-                    self.loaded_skills[skill.name] = skill
+                    register(skill)
 
         # Log discovery summary
-        if skills:
-            system_count = sum(1 for s in skills if s.location == "system")
-            user_count = sum(1 for s in skills if s.location == "user")
-            project_count = sum(1 for s in skills if s.location == "project")
+        if self.loaded_skills:
+            selected = list(self.loaded_skills.values())
+            system_count = sum(1 for s in selected if s.location == "system")
+            user_count = sum(1 for s in selected if s.location == "user")
+            project_count = sum(1 for s in selected if s.location == "project")
             parts: list[str] = []
             if system_count > 0:
                 parts.append(f"{system_count} system")
@@ -188,7 +180,7 @@ class SkillLoader:
                 parts.append(f"{user_count} user")
             if project_count > 0:
                 parts.append(f"{project_count} project")
-            log_debug(f"Discovered {len(skills)} Claude Skills ({', '.join(parts)})")
+            log_debug(f"Loaded {len(self.loaded_skills)} Claude Skills ({', '.join(parts)})")
 
         return skills
 
@@ -224,62 +216,14 @@ class SkillLoader:
             XML string with all skill metadata
         """
         xml_parts: list[str] = []
-        for skill in self.loaded_skills.values():
-            xml_parts.append(f"""<skill>
+        # Prefer showing higher-priority skills first (project > user > system).
+        location_order = {"project": 0, "user": 1, "system": 2}
+        for skill in sorted(self.loaded_skills.values(), key=lambda s: location_order.get(s.location, 3)):
+            xml_parts.append(
+                f"""<skill>
 <name>{skill.name}</name>
 <description>{skill.description}</description>
-<location>{skill.location}</location>
-</skill>""")
+<location>{skill.skill_path}</location>
+</skill>"""
+            )
         return "\n".join(xml_parts)
-
-    def _process_skill_paths(self, content: str, skill_dir: Path) -> str:
-        """Convert relative paths to absolute paths for Level 3+
-
-        Supports:
-        - scripts/, examples/, templates/, reference/ directories
-        - Markdown document references
-        - Markdown links [text](path)
-
-        Args:
-            content: Original skill content
-            skill_dir: Directory containing the SKILL.md file
-
-        Returns:
-            Content with absolute paths
-        """
-        # Pattern 1: Directory-based paths (scripts/, examples/, etc.)
-        # e.g., "python scripts/generate.py" -> "python /abs/path/to/scripts/generate.py"
-        dir_pattern = r"\b(scripts|examples|templates|reference)/([^\s\)]+)"
-
-        def replace_dir_path(match: re.Match[str]) -> str:
-            directory = match.group(1)
-            filename = match.group(2)
-            abs_path = skill_dir / directory / filename
-            return str(abs_path)
-
-        content = re.sub(dir_pattern, replace_dir_path, content)
-
-        # Pattern 2: Markdown links [text](./path or path)
-        # e.g., "[Guide](./docs/guide.md)" -> "[Guide](`/abs/path/to/docs/guide.md`) (use the Read tool to access)"
-        link_pattern = r"\[([^\]]+)\]\((\./)?([^\)]+\.md)\)"
-
-        def replace_link(match: re.Match[str]) -> str:
-            text = match.group(1)
-            filename = match.group(3)
-            abs_path = skill_dir / filename
-            return f"[{text}](`{abs_path}`) (use the Read tool to access)"
-
-        content = re.sub(link_pattern, replace_link, content)
-
-        # Pattern 3: Standalone markdown references
-        # e.g., "see reference.md" -> "see `/abs/path/to/reference.md` (use the Read tool to access)"
-        standalone_pattern = r"(?<!\])\b(\w+\.md)\b(?!\))"
-
-        def replace_standalone(match: re.Match[str]) -> str:
-            filename = match.group(1)
-            abs_path = skill_dir / filename
-            return f"`{abs_path}` (use the Read tool to access)"
-
-        content = re.sub(standalone_pattern, replace_standalone, content)
-
-        return content

klaude_code/skill/manager.py

@@ -68,3 +68,41 @@ def list_skill_names() -> list[str]:
         List of skill names
     """
     return _ensure_initialized().list_skills()
+
+
+def format_available_skills_for_system_prompt() -> str:
+    """Format skills metadata for inclusion in the system prompt.
+
+    This follows the progressive-disclosure approach:
+    - Keep only name/description + file location in the always-on system prompt
+    - Load the full SKILL.md content on demand via the Read tool when needed
+    """
+
+    try:
+        loader = _ensure_initialized()
+        skills_xml = loader.get_skills_xml().strip()
+        if not skills_xml:
+            return ""
+
+        return f"""\
+# Skills
+
+Skills are optional task-specific instructions stored as `SKILL.md` files.
+
+How to use skills:
+- Use the metadata in <available_skills> to decide whether a skill applies.
+- When the task matches a skill's description, use the `Read` tool to load the `SKILL.md` at the given <location>.
+- If the user explicitly activates a skill by starting their message with `$skill-name`, prioritize that skill.
+
+Important:
+- Only use skills listed in <available_skills> below.
+- Keep context small: do NOT load skill files unless needed.
+
+The list below is metadata only (name/description/location). The full instructions live in the referenced file.
+
+<available_skills>
+{skills_xml}
+</available_skills>"""
+    except Exception:
+        # Skills are an optional enhancement; do not fail prompt construction if discovery breaks.
+        return ""

klaude_code/tui/command/__init__.py

@@ -30,6 +30,7 @@ def ensure_commands_loaded() -> None:
 
     # Import and register commands in display order
     from .clear_cmd import ClearCommand
+    from .copy_cmd import CopyCommand
     from .debug_cmd import DebugCommand
     from .export_cmd import ExportCommand
     from .export_online_cmd import ExportOnlineCommand
@@ -44,17 +45,18 @@ def ensure_commands_loaded() -> None:
     from .thinking_cmd import ThinkingCommand
 
     # Register in desired display order
+    register(CopyCommand())
     register(ExportCommand())
-    register(ExportOnlineCommand())
     register(RefreshTerminalCommand())
-    register(ThinkingCommand())
     register(ModelCommand())
+    register(ThinkingCommand())
     register(ForkSessionCommand())
-    register(ResumeCommand())
     load_prompt_commands()
     register(StatusCommand())
+    register(ResumeCommand())
     register(HelpCommand())
     register(ReleaseNotesCommand())
+    register(ExportOnlineCommand())
     register(TerminalSetupCommand())
     register(DebugCommand())
     register(ClearCommand())
@@ -66,6 +68,7 @@ def ensure_commands_loaded() -> None:
 def __getattr__(name: str) -> object:
     _commands_map = {
         "ClearCommand": "clear_cmd",
+        "CopyCommand": "copy_cmd",
         "DebugCommand": "debug_cmd",
         "ExportCommand": "export_cmd",
         "ExportOnlineCommand": "export_online_cmd",

klaude_code/tui/command/clear_cmd.py

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

klaude_code/tui/command/command_abc.py

@@ -43,8 +43,7 @@ class CommandResult(BaseModel):
     operations: list[op.Operation] | None = None
 
     # Persistence controls: some slash commands are UI/control actions and should not be written to session history.
-    persist_user_input: bool = True
-    persist_events: bool = True
+    persist: bool = True
 
 
 class CommandABC(ABC):