klaude-code 2.1.0__tar.gz → 2.1.1__tar.gz

{klaude_code-2.1.0 → klaude_code-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.1.0
+Version: 2.1.1
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0

{klaude_code-2.1.0 → klaude_code-2.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "2.1.0"
+version = "2.1.1"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"

{klaude_code-2.1.0 → klaude_code-2.1.1}/src/klaude_code/core/agent_profile.py

@@ -150,10 +150,17 @@ def load_system_prompt(
         base_prompt = _load_base_prompt(file_key)
 
     if protocol == llm_param.LLMClientProtocol.CODEX_OAUTH:
-        # Do not append environment info for Codex protocol
+        # Do not append environment info or skills info for Codex protocol.
         return base_prompt
 
-    return base_prompt + _build_env_info(model_name)
+    skills_prompt = ""
+    if sub_agent_type is None:
+        # Skills are progressive-disclosure: keep only metadata in the system prompt.
+        from klaude_code.skill.manager import format_available_skills_for_system_prompt
+
+        skills_prompt = format_available_skills_for_system_prompt()
+
+    return base_prompt + _build_env_info(model_name) + skills_prompt
 
 
 def load_agent_tools(
@@ -180,7 +187,7 @@ def load_agent_tools(
         tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.TODO_WRITE]
 
     tool_names.extend(sub_agent_tool_names(enabled_only=True, model_name=model_name))
-    tool_names.extend([tools.SKILL, tools.MERMAID])
+    tool_names.extend([tools.MERMAID])
     # tool_names.extend([tools.MEMORY])
     return get_tool_schemas(tool_names)
 

{klaude_code-2.1.0 → klaude_code-2.1.1}/src/klaude_code/core/reminders.py

@@ -444,16 +444,32 @@ async def skill_reminder(session: Session) -> message.DeveloperMessage | None:
     if not skill:
         return None
 
-    # Get base directory from skill_path
-    base_dir = str(skill.skill_path.parent) if skill.skill_path else "unknown"
+    if not skill.skill_path.exists() or not skill.skill_path.is_file():
+        return None
+
+    tool_context = ToolContext(
+        file_tracker=session.file_tracker,
+        todo_context=build_todo_context(session),
+        session_id=session.id,
+    )
+    args = ReadTool.ReadArguments(file_path=str(skill.skill_path))
+    tool_result = await ReadTool.call_with_args(args, tool_context)
+
+    tool_args = args.model_dump_json(exclude_none=True)
+    skill_file_str = f"""Called the {tools.READ} tool with the following input: {tool_args}
+Result of calling the {tools.READ} tool:
+{tool_result.output_text}
+"""
 
-    content = f"""<system-reminder>The user activated the "{skill.name}" skill. Here is the skill content:
+    base_dir = str(skill.base_dir)
+    content = f"""<system-reminder>The user activated the "{skill.name}" skill.
 
 <skill>
 <name>{skill.name}</name>
 <base_dir>{base_dir}</base_dir>
+<location>{skill.skill_path}</location>
 
-{skill.to_prompt()}
+{skill_file_str}
 </skill>
 </system-reminder>"""
 

{klaude_code-2.1.0 → klaude_code-2.1.1}/src/klaude_code/core/tool/__init__.py

@@ -7,7 +7,6 @@ from .file.write_tool import WriteTool
 from .report_back_tool import ReportBackTool
 from .shell.bash_tool import BashTool
 from .shell.command_safety import SafetyCheckResult, is_safe_command
-from .skill.skill_tool import SkillTool
 from .sub_agent_tool import SubAgentTool
 from .todo.todo_write_tool import TodoWriteTool
 from .todo.update_plan_tool import UpdatePlanTool
@@ -31,7 +30,6 @@ __all__ = [
     "RunSubtask",
     "SafetyCheckResult",
     "SimpleTruncationStrategy",
-    "SkillTool",
     "SubAgentResumeClaims",
     "SubAgentTool",
     "TodoContext",

{klaude_code-2.1.0 → klaude_code-2.1.1}/src/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(

{klaude_code-2.1.0 → klaude_code-2.1.1}/src/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-2.1.0 → klaude_code-2.1.1}/src/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-2.1.0 → klaude_code-2.1.1}/src/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-2.1.0 → klaude_code-2.1.1}/src/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-2.1.0 → klaude_code-2.1.1}/src/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-2.1.0 → klaude_code-2.1.1}/src/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-2.1.0 → klaude_code-2.1.1}/src/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
@@ -49,6 +50,7 @@ def ensure_commands_loaded() -> None:
     register(RefreshTerminalCommand())
     register(ThinkingCommand())
     register(ModelCommand())
+    register(CopyCommand())
     register(ForkSessionCommand())
     register(ResumeCommand())
     load_prompt_commands()
@@ -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-2.1.1/src/klaude_code/tui/command/copy_cmd.py

@@ -0,0 +1,53 @@
+from klaude_code.protocol import commands, events, message, model
+from klaude_code.tui.input.clipboard import copy_to_clipboard
+
+from .command_abc import Agent, CommandABC, CommandResult
+
+
+class CopyCommand(CommandABC):
+    """Copy the last assistant message to system clipboard."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.COPY
+
+    @property
+    def summary(self) -> str:
+        return "Copy last assistant message to clipboard"
+
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+
+        last = _get_last_assistant_text(agent.session.conversation_history)
+        if not last:
+            return _developer_message(agent, "(no assistant message to copy)", self.name)
+
+        copy_to_clipboard(last)
+        return _developer_message(agent, "Copied last assistant message to clipboard.", self.name)
+
+
+def _get_last_assistant_text(history: list[message.HistoryEvent]) -> str:
+    for item in reversed(history):
+        if not isinstance(item, message.AssistantMessage):
+            continue
+        content = message.join_text_parts(item.parts)
+        images = [part for part in item.parts if isinstance(part, message.ImageFilePart)]
+        formatted = message.format_saved_images(images, content)
+        return formatted.strip()
+    return ""
+
+
+def _developer_message(agent: Agent, content: str, command_name: commands.CommandName) -> CommandResult:
+    return CommandResult(
+        events=[
+            events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=message.DeveloperMessage(
+                    parts=message.text_parts_from_str(content),
+                    ui_extra=model.build_command_output_extra(command_name),
+                ),
+            )
+        ],
+        persist_user_input=False,
+        persist_events=False,
+    )

{klaude_code-2.1.0 → klaude_code-2.1.1}/src/klaude_code/tui/components/tools.py

@@ -37,7 +37,6 @@ MARK_MERMAID = "⧉"
 MARK_WEB_FETCH = "→"
 MARK_WEB_SEARCH = "✱"
 MARK_DONE = "✔"
-MARK_SKILL = "✪"
 
 # Todo status markers
 MARK_TODO_PENDING = "▢"
@@ -491,7 +490,7 @@ def render_mermaid_tool_result(
 
     link_info = _extract_mermaid_link(tr.ui_extra)
     if link_info is None:
-        return render_generic_tool_result(tr.result, is_error=tr.status == "error")
+        return render_generic_tool_result(tr.result, is_error=tr.is_error)
 
     use_osc8 = supports_osc8_hyperlinks()
     viewer = _render_mermaid_viewer_link(tr, link_info, use_osc8=use_osc8)
@@ -537,7 +536,6 @@ _TOOL_ACTIVE_FORM: dict[str, str] = {
     tools.WRITE: "Writing",
     tools.TODO_WRITE: "Planning",
     tools.UPDATE_PLAN: "Planning",
-    tools.SKILL: "Skilling",
     tools.MERMAID: "Diagramming",
     tools.WEB_FETCH: "Fetching Web",
     tools.WEB_SEARCH: "Searching Web",
@@ -589,8 +587,6 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
             return render_update_plan_tool_call(e.arguments)
         case tools.MERMAID:
             return render_mermaid_tool_call(e.arguments)
-        case tools.SKILL:
-            return render_generic_tool_call(e.tool_name, e.arguments, MARK_SKILL)
         case tools.REPORT_BACK:
             return render_report_back_tool_call()
         case tools.WEB_FETCH:
@@ -649,7 +645,7 @@ def render_tool_result(
         return TreeQuote.for_tool_result(content, is_last=e.is_last_in_turn)
 
     # Handle error case
-    if e.status == "error" and e.ui_extra is None:
+    if e.is_error and e.ui_extra is None:
         return wrap(render_generic_tool_result(e.result, is_error=True))
 
     # Render multiple ui blocks if present
@@ -666,7 +662,7 @@ def render_tool_result(
     # Show truncation info if output was truncated and saved to file
     truncation_info = get_truncation_info(e)
     if truncation_info:
-        result = render_generic_tool_result(e.result, is_error=e.status == "error")
+        result = render_generic_tool_result(e.result, is_error=e.is_error)
         return wrap(Group(render_truncation_info(truncation_info), result))
 
     diff_ui = _extract_diff(e.ui_extra)
@@ -675,7 +671,7 @@ def render_tool_result(
     def _render_fallback() -> TreeQuote:
         if len(e.result.strip()) == 0:
             return wrap(render_generic_tool_result("(no content)"))
-        return wrap(render_generic_tool_result(e.result, is_error=e.status == "error"))
+        return wrap(render_generic_tool_result(e.result, is_error=e.is_error))
 
     match e.tool_name:
         case tools.READ:

{klaude_code-2.1.0 → klaude_code-2.1.1}/src/klaude_code/tui/machine.py

@@ -521,13 +521,15 @@ class DisplayStateMachine:
                     self._spinner.finish_sub_agent_tool_call(e.tool_call_id, get_tool_active_form(e.tool_name))
                     cmds.extend(self._spinner_update_commands())
 
-                if s.is_sub_agent and e.status == "success":
+                if s.is_sub_agent and not e.is_error:
                     return cmds
 
                 cmds.append(RenderToolResult(event=e, is_sub_agent_session=s.is_sub_agent))
                 return cmds
 
             case events.TaskMetadataEvent() as e:
+                cmds.append(EndThinkingStream(e.session_id))
+                cmds.append(EndAssistantStream(e.session_id))
                 cmds.append(RenderTaskMetadata(e))
                 return cmds
 

{klaude_code-2.1.0 → klaude_code-2.1.1}/src/klaude_code/tui/renderer.py

@@ -396,7 +396,7 @@ class TUICommandRenderer:
         if c_tools.is_sub_agent_tool(e.tool_name):
             return
 
-        if is_sub_agent and e.status == "error":
+        if is_sub_agent and e.is_error:
             error_msg = truncate_head(e.result)
             self.print(c_errors.render_tool_error(error_msg))
             return

klaude_code-2.1.0/src/klaude_code/core/tool/skill/skill_tool.md

@@ -1,24 +0,0 @@
-Execute a skill within the main conversation
-
-<skills_instructions>
-When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
-
-How to use skills:
-- Invoke skills using this tool with the skill name only (no arguments)
-- When you invoke a skill, you will see <command-message>The "{name}" skill is loading</command-message>
-- The skill's prompt will expand and provide detailed instructions on how to complete the task
-
-Examples:
-- command: "pdf" - invoke the pdf skill
-- command: "xlsx" - invoke the xlsx skill
-- command: "document-skills:pdf" - invoke using fully qualified name
-
-Important:
-- Only use skills listed in <available_skills> below
-- Do not invoke a skill that is already running
-- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)
-</skills_instructions>
-
-<available_skills>
-$skills_xml
-</available_skills>