klaude-code 1.2.22__tar.gz → 1.2.24__tar.gz

{klaude_code-1.2.22 → klaude_code-1.2.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.22
+Version: 1.2.24
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
@@ -18,18 +18,23 @@ Requires-Dist: typer>=0.17.3
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 
-# Minimal Code Agent CLI (Klaude Code)
-
-An minimal and opinionated code agent with multi-model support.
-
-## Key Features
-- **Adaptive Tooling**: Model-aware toolsets (Claude Code tools for Sonnet, Codex `apply_patch` for GPT-5.1/Codex).
-- **Multi-Provider Support**: Compatible with `anthropic-messages-api`,`openai-responses-api`, and `openai-compatible-api`(`openrouter-api`),  featuring interleaved thinking, OpenRouter's provider sorting etc.
-- **Structured Sub-Agent Output**: Main agent defines output JSON schema for sub-agents; sub-agents use `report_back` tool with constrained decoding to return schema-compliant structured data.
-- **Skill System**: Extensible support for loading Claude Skills.
-- **Session Management**: Robust context preservation with resumable sessions (`--continue`).
-- **Simple TUI**: Clean interface offering full visibility into model responses, reasoning and actions.
-- **Core Utilities**: Slash commands, sub-agents, image pasting, terminal notifications, file mentioning, and auto-theming.
+# Klaude Code
+
+Multi-model code agent CLI.
+
+## Features
+- **Multi-provider**: Anthropic, OpenAI Responses API, OpenRouter
+- **Keep reasoning item in context**: Interleaved thinking support
+- **Model-aware tools**: Claude Code tools for Sonnet, `apply_patch` for GPT-5/Codex
+- **Structured sub-agent output**: Define JSON schema, get schema-compliant responses via constrained decoding
+- **Recursive `@file` mentions**: Circular dependency protection, relative path resolution
+- **Reminders**: Cooldown-based todo tracking and instruction reinforcement
+- **External file sync**: Monitoring for external edits (linter, manual)
+- **Interrupt handling**: Ctrl+C preserves partial responses and synthesizes tool cancellation results
+- **Output truncation**: Large outputs saved to file system with snapshot links
+- **Skills**: Built-in + user + project Agent Skills (with implicit invocation by Skill tool or explicit invocation by typing `$`)
+- **Sessions**: Resumable with `--continue`
+- **Extras**: Slash commands, sub-agents, image paste, terminal notifications, auto-theming
 
 ## Installation
 

{klaude_code-1.2.22 → klaude_code-1.2.24}/README.md

@@ -1,15 +1,20 @@
-# Minimal Code Agent CLI (Klaude Code)
-
-An minimal and opinionated code agent with multi-model support.
-
-## Key Features
-- **Adaptive Tooling**: Model-aware toolsets (Claude Code tools for Sonnet, Codex `apply_patch` for GPT-5.1/Codex).
-- **Multi-Provider Support**: Compatible with `anthropic-messages-api`,`openai-responses-api`, and `openai-compatible-api`(`openrouter-api`),  featuring interleaved thinking, OpenRouter's provider sorting etc.
-- **Structured Sub-Agent Output**: Main agent defines output JSON schema for sub-agents; sub-agents use `report_back` tool with constrained decoding to return schema-compliant structured data.
-- **Skill System**: Extensible support for loading Claude Skills.
-- **Session Management**: Robust context preservation with resumable sessions (`--continue`).
-- **Simple TUI**: Clean interface offering full visibility into model responses, reasoning and actions.
-- **Core Utilities**: Slash commands, sub-agents, image pasting, terminal notifications, file mentioning, and auto-theming.
+# Klaude Code
+
+Multi-model code agent CLI.
+
+## Features
+- **Multi-provider**: Anthropic, OpenAI Responses API, OpenRouter
+- **Keep reasoning item in context**: Interleaved thinking support
+- **Model-aware tools**: Claude Code tools for Sonnet, `apply_patch` for GPT-5/Codex
+- **Structured sub-agent output**: Define JSON schema, get schema-compliant responses via constrained decoding
+- **Recursive `@file` mentions**: Circular dependency protection, relative path resolution
+- **Reminders**: Cooldown-based todo tracking and instruction reinforcement
+- **External file sync**: Monitoring for external edits (linter, manual)
+- **Interrupt handling**: Ctrl+C preserves partial responses and synthesizes tool cancellation results
+- **Output truncation**: Large outputs saved to file system with snapshot links
+- **Skills**: Built-in + user + project Agent Skills (with implicit invocation by Skill tool or explicit invocation by typing `$`)
+- **Sessions**: Resumable with `--continue`
+- **Extras**: Slash commands, sub-agents, image paste, terminal notifications, auto-theming
 
 ## Installation
 

{klaude_code-1.2.22 → klaude_code-1.2.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.22"
+version = "1.2.24"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -81,6 +81,7 @@ layers = [
     "klaude_code.cli",
     "klaude_code.ui",
     "klaude_code.core",
+    "klaude_code.skill",
     "klaude_code.command",
     "klaude_code.session",
     "klaude_code.config",

klaude_code-1.2.24/src/klaude_code/command/prompt-jj-describe.md

@@ -0,0 +1,32 @@
+---
+description: Add description for current jj change
+---
+
+Run `jj status` and `jj diff --git` to see the current changes and add a description for the it.
+
+In order to ensure good formatting, ALWAYS pass the commit message via a HEREDOC, a la this example:<example>
+jj describe -m "$(cat <<'EOF'
+   Commit message here.
+   EOF
+   )"
+</example>
+
+Follow the [Conventional Commits](https://www.conventionalcommits.org/) specification:
+```
+<type>(<scope>): <description>
+```
+
+Types:
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code style changes (formatting, no logic change)
+- `refactor`: Code refactoring (no feature or fix)
+- `test`: Adding or updating tests
+- `chore`: Build process, dependencies, or tooling changes
+
+Examples:
+- `feat(cli): add --verbose flag for debug output`
+- `fix(llm): handle API timeout errors gracefully`
+- `docs(readme): update installation instructions`
+- `refactor(core): simplify session state management`

{klaude_code-1.2.22 → klaude_code-1.2.24}/src/klaude_code/command/status_cmd.py

@@ -22,7 +22,7 @@ def accumulate_session_usage(session: Session) -> AggregatedUsage:
     for item in session.conversation_history:
         if isinstance(item, model.TaskMetadataItem):
             task_count += 1
-            all_metadata.append(item.main)
+            all_metadata.append(item.main_agent)
             all_metadata.extend(item.sub_agent_task_metadata)
 
     # Aggregate by model+provider

klaude_code-1.2.22/src/klaude_code/const/__init__.py → klaude_code-1.2.24/src/klaude_code/const.py

@@ -90,10 +90,10 @@ INVALID_TOOL_CALL_MAX_LENGTH = 500
 TRUNCATE_DISPLAY_MAX_LINE_LENGTH = 1000
 
 # Maximum lines for truncated display output
-TRUNCATE_DISPLAY_MAX_LINES = 20
+TRUNCATE_DISPLAY_MAX_LINES = 8
 
 # Maximum lines for sub-agent result display
-SUB_AGENT_RESULT_MAX_LINES = 12
+SUB_AGENT_RESULT_MAX_LINES = 50
 
 
 # UI refresh rate (frames per second) for debounced content streaming
@@ -102,9 +102,18 @@ UI_REFRESH_RATE_FPS = 20
 # Number of lines to keep visible at bottom of markdown streaming window
 MARKDOWN_STREAM_LIVE_WINDOW = 6
 
+# Left margin (columns) to reserve when rendering markdown
+MARKDOWN_LEFT_MARGIN = 2
+
+# Right margin (columns) to reserve when rendering markdown
+MARKDOWN_RIGHT_MARGIN = 2
+
 # Status hint text shown after spinner status
 STATUS_HINT_TEXT = " (esc to interrupt)"
 
+# Default spinner status text when idle/thinking
+STATUS_DEFAULT_TEXT = "Thinking …"
+
 # Status shimmer animation
 # Horizontal padding used when computing shimmer band position
 STATUS_SHIMMER_PADDING = 10

{klaude_code-1.2.22 → klaude_code-1.2.24}/src/klaude_code/core/executor.py

@@ -327,7 +327,7 @@ class ExecutorContext:
             log_debug(traceback.format_exc(), style="red", debug_type=DebugType.EXECUTION)
             await self.emit_event(
                 events.ErrorEvent(
-                    error_message=f"Agent task failed: [{e.__class__.__name__}] {e!s}",
+                    error_message=f"Agent task failed: [{e.__class__.__name__}] {e!s} {traceback.format_exc()}",
                     can_retry=False,
                 )
             )

{klaude_code-1.2.22 → klaude_code-1.2.24}/src/klaude_code/core/manager/sub_agent_manager.py

@@ -89,7 +89,7 @@ Only the content passed to `report_back` will be returned to user.\
                     result = event.task_result
                 # Capture TaskMetadataEvent for metadata propagation
                 elif isinstance(event, events.TaskMetadataEvent):
-                    task_metadata = event.metadata.main
+                    task_metadata = event.metadata.main_agent
                 await self.emit_event(event)
             return SubAgentResult(
                 task_result=result,

{klaude_code-1.2.22 → klaude_code-1.2.24}/src/klaude_code/core/reminders.py

@@ -12,6 +12,7 @@ from klaude_code.core.tool import BashTool, ReadTool, reset_tool_context, set_to
 from klaude_code.core.tool.file._utils import hash_text_sha256
 from klaude_code.protocol import model, tools
 from klaude_code.session import Session
+from klaude_code.skill import get_skill
 
 type Reminder = Callable[[Session], Awaitable[model.DeveloperMessageItem | None]]
 
@@ -19,6 +20,9 @@ type Reminder = Callable[[Session], Awaitable[model.DeveloperMessageItem | None]
 # Match @ preceded by whitespace, start of line, or → (ReadTool line number arrow)
 AT_FILE_PATTERN = re.compile(r'(?:(?<!\S)|(?<=\u2192))@("(?P<quoted>[^\"]+)"|(?P<plain>\S+))')
 
+# Match $skill or ¥skill at the beginning of the first line
+SKILL_PATTERN = re.compile(r"^[$¥](?P<skill>\S+)")
+
 
 def get_last_new_user_input(session: Session) -> str | None:
     """Get last user input & developer message (CLAUDE.md) from conversation history. if there's a tool result after user input, return None"""
@@ -73,6 +77,21 @@ def get_at_patterns_with_source(session: Session) -> list[AtPatternSource]:
     return patterns
 
 
+def get_skill_from_user_input(session: Session) -> str | None:
+    """Get $skill reference from the first line of last user input."""
+    for item in reversed(session.conversation_history):
+        if isinstance(item, model.ToolResultItem):
+            return None
+        if isinstance(item, model.UserMessageItem):
+            content = item.content or ""
+            first_line = content.split("\n", 1)[0]
+            m = SKILL_PATTERN.match(first_line)
+            if m:
+                return m.group("skill")
+            return None
+    return None
+
+
 async def _load_at_file_recursive(
     session: Session,
     pattern: str,
@@ -373,6 +392,36 @@ async def image_reminder(session: Session) -> model.DeveloperMessageItem | None:
     )
 
 
+async def skill_reminder(session: Session) -> model.DeveloperMessageItem | None:
+    """Load skill content when user references a skill with $skill syntax."""
+    skill_name = get_skill_from_user_input(session)
+    if not skill_name:
+        return None
+
+    # Get the skill from skill module
+    skill = get_skill(skill_name)
+    if not skill:
+        return None
+
+    # Get base directory from skill_path
+    base_dir = str(skill.skill_path.parent) if skill.skill_path else "unknown"
+
+    content = f"""<system-reminder>The user activated the "{skill.name}" skill. Here is the skill content:
+
+<skill>
+<name>{skill.name}</name>
+<base_dir>{base_dir}</base_dir>
+
+{skill.to_prompt()}
+</skill>
+</system-reminder>"""
+
+    return model.DeveloperMessageItem(
+        content=content,
+        skill_name=skill.name,
+    )
+
+
 def _is_memory_loaded(session: Session, path: str) -> bool:
     """Check if a memory file has already been loaded (tracked with is_memory=True)."""
     status = session.file_tracker.get(path)
@@ -510,6 +559,7 @@ ALL_REMINDERS = [
     last_path_memory_reminder,
     at_file_reader_reminder,
     image_reminder,
+    skill_reminder,
 ]
 
 
@@ -540,6 +590,7 @@ def load_agent_reminders(
             last_path_memory_reminder,
             file_changed_externally_reminder,
             image_reminder,
+            skill_reminder,
         ]
     )
 

{klaude_code-1.2.22 → klaude_code-1.2.24}/src/klaude_code/core/task.py

@@ -25,7 +25,7 @@ class MetadataAccumulator:
     """
 
     def __init__(self, model_name: str) -> None:
-        self._main = model.TaskMetadata(model_name=model_name)
+        self._main_agent = model.TaskMetadata(model_name=model_name)  # Main agent metadata
         self._sub_agent_metadata: list[model.TaskMetadata] = []
         self._throughput_weighted_sum: float = 0.0
         self._throughput_tracked_tokens: int = 0
@@ -36,13 +36,12 @@ class MetadataAccumulator:
     def add(self, turn_metadata: model.ResponseMetadataItem) -> None:
         """Merge a turn's metadata into the accumulated state."""
         self._turn_count += 1
-        main = self._main
         usage = turn_metadata.usage
 
         if usage is not None:
-            if main.usage is None:
-                main.usage = model.Usage()
-            acc_usage = main.usage
+            if self._main_agent.usage is None:
+                self._main_agent.usage = model.Usage()
+            acc_usage = self._main_agent.usage
 
             model.TaskMetadata.merge_usage(acc_usage, usage)
             acc_usage.currency = usage.currency
@@ -63,9 +62,9 @@ class MetadataAccumulator:
                     self._throughput_tracked_tokens += current_output
 
         if turn_metadata.provider is not None:
-            main.provider = turn_metadata.provider
+            self._main_agent.provider = turn_metadata.provider
         if turn_metadata.model_name:
-            main.model_name = turn_metadata.model_name
+            self._main_agent.model_name = turn_metadata.model_name
 
     def add_sub_agent_metadata(self, sub_agent_metadata: model.TaskMetadata) -> None:
         """Add sub-agent task metadata to the accumulated state."""
@@ -73,21 +72,22 @@ class MetadataAccumulator:
 
     def finalize(self, task_duration_s: float) -> model.TaskMetadataItem:
         """Return the final accumulated metadata with computed throughput and duration."""
-        main = self._main
-        if main.usage is not None:
+        if self._main_agent.usage is not None:
             if self._throughput_tracked_tokens > 0:
-                main.usage.throughput_tps = self._throughput_weighted_sum / self._throughput_tracked_tokens
+                self._main_agent.usage.throughput_tps = self._throughput_weighted_sum / self._throughput_tracked_tokens
             else:
-                main.usage.throughput_tps = None
+                self._main_agent.usage.throughput_tps = None
 
             if self._first_token_latency_count > 0:
-                main.usage.first_token_latency_ms = self._first_token_latency_sum / self._first_token_latency_count
+                self._main_agent.usage.first_token_latency_ms = (
+                    self._first_token_latency_sum / self._first_token_latency_count
+                )
             else:
-                main.usage.first_token_latency_ms = None
+                self._main_agent.usage.first_token_latency_ms = None
 
-        main.task_duration_s = task_duration_s
-        main.turn_count = self._turn_count
-        return model.TaskMetadataItem(main=main, sub_agent_task_metadata=self._sub_agent_metadata)
+        self._main_agent.task_duration_s = task_duration_s
+        self._main_agent.turn_count = self._turn_count
+        return model.TaskMetadataItem(main_agent=self._main_agent, sub_agent_task_metadata=self._sub_agent_metadata)
 
 
 @dataclass
@@ -126,17 +126,28 @@ class TaskExecutor:
         self._context = context
         self._current_turn: TurnExecutor | None = None
         self._started_at: float = 0.0
+        self._metadata_accumulator: MetadataAccumulator | None = None
 
     @property
     def current_turn(self) -> TurnExecutor | None:
         return self._current_turn
 
     def cancel(self) -> list[events.Event]:
-        """Cancel the current turn and return any resulting events."""
+        """Cancel the current turn and return any resulting events including metadata."""
         ui_events: list[events.Event] = []
         if self._current_turn is not None:
             ui_events.extend(self._current_turn.cancel())
             self._current_turn = None
+
+        # Emit partial metadata on cancellation
+        if self._metadata_accumulator is not None and self._started_at > 0:
+            task_duration_s = time.perf_counter() - self._started_at
+            accumulated = self._metadata_accumulator.finalize(task_duration_s)
+            if accumulated.main_agent.usage is not None:
+                session_id = self._context.session_ctx.session_id
+                ui_events.append(events.TaskMetadataEvent(metadata=accumulated, session_id=session_id))
+                self._context.session_ctx.append_history([accumulated])
+
         return ui_events
 
     async def run(self, user_input: model.UserInputPayload) -> AsyncGenerator[events.Event]:
@@ -152,7 +163,8 @@ class TaskExecutor:
         del user_input  # Persisted by the operation handler before launching the task.
 
         profile = ctx.profile
-        metadata_accumulator = MetadataAccumulator(model_name=profile.llm_client.model_name)
+        self._metadata_accumulator = MetadataAccumulator(model_name=profile.llm_client.model_name)
+        metadata_accumulator = self._metadata_accumulator
 
         while True:
             # Process reminders at the start of each turn
@@ -226,6 +238,13 @@ class TaskExecutor:
                 return
 
             if turn is None or turn.task_finished:
+                # Sub-agent with empty result should retry instead of finishing
+                if ctx.sub_agent_state is not None and turn is not None and not turn.task_result.strip():
+                    yield events.ErrorEvent(
+                        error_message="Sub-agent returned empty result, retrying...",
+                        can_retry=True,
+                    )
+                    continue
                 break
 
         # Finalize metadata

{klaude_code-1.2.22 → klaude_code-1.2.24}/src/klaude_code/core/tool/__init__.py

@@ -3,11 +3,10 @@ from .file.apply_patch_tool import ApplyPatchTool
 from .file.edit_tool import EditTool
 from .file.read_tool import ReadTool
 from .file.write_tool import WriteTool
-from .memory.skill_loader import Skill, SkillLoader
-from .memory.skill_tool import SkillTool
 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
@@ -40,8 +39,6 @@ __all__ = [
     "ReportBackTool",
     "SafetyCheckResult",
     "SimpleTruncationStrategy",
-    "Skill",
-    "SkillLoader",
     "SkillTool",
     "SubAgentTool",
     "TodoContext",

{klaude_code-1.2.22 → klaude_code-1.2.24}/src/klaude_code/core/tool/file/read_tool.py

@@ -25,6 +25,18 @@ _IMAGE_MIME_TYPES: dict[str, str] = {
     ".webp": "image/webp",
 }
 
+_BINARY_CHECK_SIZE = 8192
+
+
+def _is_binary_file(file_path: str) -> bool:
+    """Check if a file is binary by looking for null bytes in the first chunk."""
+    try:
+        with open(file_path, "rb") as f:
+            chunk = f.read(_BINARY_CHECK_SIZE)
+            return b"\x00" in chunk
+    except OSError:
+        return False
+
 
 def _format_numbered_line(line_no: int, content: str) -> str:
     # 6-width right-aligned line number followed by a right arrow
@@ -218,12 +230,22 @@ class ReadTool(ToolABC):
                 ),
             )
 
+        is_image_file = _is_supported_image_file(file_path)
+        # Check for binary files (skip for images which are handled separately)
+        if not is_image_file and _is_binary_file(file_path):
+            return model.ToolResultItem(
+                status="error",
+                output=(
+                    "<tool_use_error>This appears to be a binary file and cannot be read as text. "
+                    "Use appropriate tools or libraries to handle binary files.</tool_use_error>"
+                ),
+            )
+
         try:
             size_bytes = Path(file_path).stat().st_size
         except OSError:
             size_bytes = 0
 
-        is_image_file = _is_supported_image_file(file_path)
         if is_image_file:
             if size_bytes > const.READ_MAX_IMAGE_BYTES:
                 size_mb = size_bytes / (1024 * 1024)

{klaude_code-1.2.22 → klaude_code-1.2.24}/src/klaude_code/core/tool/file/write_tool.py

@@ -124,9 +124,13 @@ class WriteTool(ToolABC):
                     is_memory=is_mem,
                 )
 
-        # Build diff between previous and new content
-        after = args.content
-        ui_extra = build_structured_diff(before, after, file_path=file_path)
+        # For markdown files, use MarkdownDocUIExtra to render content as markdown
+        # Otherwise, build diff between previous and new content
+        ui_extra: model.ToolResultUIExtra | None
+        if file_path.endswith(".md"):
+            ui_extra = model.MarkdownDocUIExtra(file_path=file_path, content=args.content)
+        else:
+            ui_extra = build_structured_diff(before, args.content, file_path=file_path)
 
         message = f"File {'overwritten' if exists else 'created'} successfully at: {file_path}"
         return model.ToolResultItem(status="success", output=message, ui_extra=ui_extra)

{klaude_code-1.2.22/src/klaude_code/core/tool/memory → klaude_code-1.2.24/src/klaude_code/core/tool/skill}/skill_tool.py

@@ -1,38 +1,22 @@
+"""SkillTool - Tool for agent to activate and load skills."""
+
 from pathlib import Path
 
 from pydantic import BaseModel
 
-from klaude_code.core.tool.memory.skill_loader import SkillLoader
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
+from klaude_code.skill import get_available_skills, get_skill, list_skill_names
 
 
 @register(tools.SKILL)
 class SkillTool(ToolABC):
-    """Tool to execute/load a skill within the main conversation"""
-
-    _skill_loader: SkillLoader | None = None
-    _discovery_done: bool = False
-
-    @classmethod
-    def set_skill_loader(cls, loader: SkillLoader) -> None:
-        """Set the skill loader instance"""
-        cls._skill_loader = loader
-        cls._discovery_done = False
-
-    @classmethod
-    def _ensure_skills_discovered(cls) -> None:
-        if cls._discovery_done:
-            return
-        if cls._skill_loader is not None:
-            cls._skill_loader.discover_skills()
-        cls._discovery_done = True
+    """Tool to execute/load a skill within the main conversation."""
 
     @classmethod
     def schema(cls) -> llm_param.ToolSchema:
-        """Generate schema with embedded available skills metadata"""
-        cls._ensure_skills_discovered()
+        """Generate schema with embedded available skills metadata."""
         skills_xml = cls._generate_skills_xml()
 
         return llm_param.ToolSchema(
@@ -53,16 +37,17 @@ class SkillTool(ToolABC):
 
     @classmethod
     def _generate_skills_xml(cls) -> str:
-        """Generate XML format skills metadata"""
-        if not cls._skill_loader:
+        """Generate XML format skills metadata."""
+        skills = get_available_skills()
+        if not skills:
             return ""
 
         xml_parts: list[str] = []
-        for skill in cls._skill_loader.loaded_skills.values():
+        for name, description, location in skills:
             xml_parts.append(f"""<skill>
-<name>{skill.name}</name>
-<description>{skill.description}</description>
-<location>{skill.location}</location>
+<name>{name}</name>
+<description>{description}</description>
+<location>{location}</location>
 </skill>""")
         return "\n".join(xml_parts)
 
@@ -71,7 +56,7 @@ class SkillTool(ToolABC):
 
     @classmethod
     async def call(cls, arguments: str) -> model.ToolResultItem:
-        """Load and return full skill content"""
+        """Load and return full skill content."""
         try:
             args = cls.SkillArguments.model_validate_json(arguments)
         except ValueError as e:
@@ -80,18 +65,10 @@ class SkillTool(ToolABC):
                 output=f"Invalid arguments: {e}",
             )
 
-        cls._ensure_skills_discovered()
-
-        if not cls._skill_loader:
-            return model.ToolResultItem(
-                status="error",
-                output="Skill loader not initialized",
-            )
-
-        skill = cls._skill_loader.get_skill(args.command)
+        skill = get_skill(args.command)
 
         if not skill:
-            available = ", ".join(cls._skill_loader.list_skills())
+            available = ", ".join(list_skill_names())
             return model.ToolResultItem(
                 status="error",
                 output=f"Skill '{args.command}' does not exist. Available skills: {available}",
@@ -101,7 +78,7 @@ class SkillTool(ToolABC):
         base_dir = str(skill.skill_path.parent) if skill.skill_path else "unknown"
 
         # Return with loading message format
-        result = f"""<command-message>The "{skill.name}" skill is running</command-message>
+        result = f"""<command-message>The "{skill.name}" skill is activated</command-message>
 <command-name>{skill.name}</command-name>
 
 Base directory for this skill: {base_dir}