klaude-code 1.2.21__py3-none-any.whl → 1.2.23__py3-none-any.whl

klaude_code/core/tool/file/read_tool.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+import hashlib
 import os
 from base64 import b64encode
 from dataclasses import dataclass
@@ -37,6 +38,7 @@ class ReadOptions:
     limit: int | None
     char_limit_per_line: int | None = const.READ_CHAR_LIMIT_PER_LINE
     global_line_cap: int | None = const.READ_GLOBAL_LINE_CAP
+    max_total_chars: int | None = const.READ_MAX_CHARS
 
 
 @dataclass
@@ -45,29 +47,32 @@ class ReadSegmentResult:
     selected_lines: list[tuple[int, str]]
     selected_chars_count: int
     remaining_selected_beyond_cap: int
-    # For large file diagnostics: list of (start_line, end_line, char_count)
-    segment_char_stats: list[tuple[int, int, int]]
+    remaining_due_to_char_limit: int
+    content_sha256: str
 
 
 def _read_segment(options: ReadOptions) -> ReadSegmentResult:
     total_lines = 0
     selected_lines_count = 0
     remaining_selected_beyond_cap = 0
+    remaining_due_to_char_limit = 0
     selected_lines: list[tuple[int, str]] = []
     selected_chars = 0
-
-    # Track char counts per 100-line segment for diagnostics
-    segment_size = 100
-    segment_char_stats: list[tuple[int, int, int]] = []
-    current_segment_start = options.offset
-    current_segment_chars = 0
+    char_limit_reached = False
+    hasher = hashlib.sha256()
 
     with open(options.file_path, encoding="utf-8", errors="replace") as f:
         for line_no, raw_line in enumerate(f, start=1):
             total_lines = line_no
+            hasher.update(raw_line.encode("utf-8"))
             within = line_no >= options.offset and (options.limit is None or selected_lines_count < options.limit)
             if not within:
                 continue
+
+            if char_limit_reached:
+                remaining_due_to_char_limit += 1
+                continue
+
             selected_lines_count += 1
             content = raw_line.rstrip("\n")
             original_len = len(content)
@@ -79,42 +84,39 @@ def _read_segment(options: ReadOptions) -> ReadSegmentResult:
                 )
             line_chars = len(content) + 1
             selected_chars += line_chars
-            current_segment_chars += line_chars
 
-            # Check if we've completed a segment
-            if selected_lines_count % segment_size == 0:
-                segment_char_stats.append((current_segment_start, line_no, current_segment_chars))
-                current_segment_start = line_no + 1
-                current_segment_chars = 0
+            if options.max_total_chars is not None and selected_chars > options.max_total_chars:
+                char_limit_reached = True
+                selected_lines.append((line_no, content))
+                continue
 
             if options.global_line_cap is None or len(selected_lines) < options.global_line_cap:
                 selected_lines.append((line_no, content))
             else:
                 remaining_selected_beyond_cap += 1
 
-    # Add the last partial segment if any
-    if current_segment_chars > 0 and selected_lines_count > 0:
-        last_line = options.offset + selected_lines_count - 1
-        segment_char_stats.append((current_segment_start, last_line, current_segment_chars))
-
     return ReadSegmentResult(
         total_lines=total_lines,
         selected_lines=selected_lines,
         selected_chars_count=selected_chars,
         remaining_selected_beyond_cap=remaining_selected_beyond_cap,
-        segment_char_stats=segment_char_stats,
+        remaining_due_to_char_limit=remaining_due_to_char_limit,
+        content_sha256=hasher.hexdigest(),
     )
 
 
-def _track_file_access(file_path: str, *, is_memory: bool = False) -> None:
+def _track_file_access(file_path: str, *, content_sha256: str | None = None, is_memory: bool = False) -> None:
     file_tracker = get_current_file_tracker()
     if file_tracker is None or not file_exists(file_path) or is_directory(file_path):
         return
     with contextlib.suppress(Exception):
         existing = file_tracker.get(file_path)
-        # Preserve is_memory flag if already set
         is_mem = is_memory or (existing.is_memory if existing else False)
-        file_tracker[file_path] = model.FileStatus(mtime=Path(file_path).stat().st_mtime, is_memory=is_mem)
+        file_tracker[file_path] = model.FileStatus(
+            mtime=Path(file_path).stat().st_mtime,
+            content_sha256=content_sha256,
+            is_memory=is_mem,
+        )
 
 
 def _is_supported_image_file(file_path: str) -> bool:
@@ -129,12 +131,6 @@ def _image_mime_type(file_path: str) -> str:
     return mime_type
 
 
-def _encode_image_to_data_url(file_path: str, mime_type: str) -> str:
-    with open(file_path, "rb") as image_file:
-        encoded = b64encode(image_file.read()).decode("ascii")
-    return f"data:{mime_type};base64,{encoded}"
-
-
 @register(tools.READ)
 class ReadTool(ToolABC):
     class ReadArguments(BaseModel):
@@ -178,24 +174,18 @@ class ReadTool(ToolABC):
         return await cls.call_with_args(args)
 
     @classmethod
-    def _effective_limits(cls) -> tuple[int | None, int | None, int | None, int | None]:
-        """Return effective limits based on current policy: char_per_line, global_line_cap, max_chars, max_kb"""
+    def _effective_limits(cls) -> tuple[int | None, int | None, int | None]:
         return (
             const.READ_CHAR_LIMIT_PER_LINE,
             const.READ_GLOBAL_LINE_CAP,
             const.READ_MAX_CHARS,
-            const.READ_MAX_KB,
         )
 
     @classmethod
     async def call_with_args(cls, args: ReadTool.ReadArguments) -> model.ToolResultItem:
-        # Accept relative path by resolving to absolute (schema encourages absolute)
         file_path = os.path.abspath(args.file_path)
+        char_per_line, line_cap, max_chars = cls._effective_limits()
 
-        # Get effective limits based on policy
-        char_per_line, line_cap, max_chars, max_kb = cls._effective_limits()
-
-        # Common file errors
         if is_directory(file_path):
             return model.ToolResultItem(
                 status="error",
@@ -228,11 +218,9 @@ class ReadTool(ToolABC):
                 ),
             )
 
-        # If file is too large and no pagination provided (only check if limits are enabled)
         try:
             size_bytes = Path(file_path).stat().st_size
         except OSError:
-            # Best-effort size detection; on stat errors fall back to treating size as unknown.
             size_bytes = 0
 
         is_image_file = _is_supported_image_file(file_path)
@@ -247,42 +235,26 @@ class ReadTool(ToolABC):
                 )
             try:
                 mime_type = _image_mime_type(file_path)
-                data_url = _encode_image_to_data_url(file_path, mime_type)
+                with open(file_path, "rb") as image_file:
+                    image_bytes = image_file.read()
+                data_url = f"data:{mime_type};base64,{b64encode(image_bytes).decode('ascii')}"
             except Exception as exc:
                 return model.ToolResultItem(
                     status="error",
                     output=f"<tool_use_error>Failed to read image file: {exc}</tool_use_error>",
                 )
 
-            _track_file_access(file_path)
+            _track_file_access(file_path, content_sha256=hashlib.sha256(image_bytes).hexdigest())
             size_kb = size_bytes / 1024.0 if size_bytes else 0.0
             output_text = f"[image] {Path(file_path).name} ({size_kb:.1f}KB)"
             image_part = model.ImageURLPart(image_url=model.ImageURLPart.ImageURL(url=data_url, id=None))
             return model.ToolResultItem(status="success", output=output_text, images=[image_part])
 
-        if (
-            not is_image_file
-            and max_kb is not None
-            and args.offset is None
-            and args.limit is None
-            and size_bytes > max_kb * 1024
-        ):
-            size_kb = size_bytes / 1024.0
-            return model.ToolResultItem(
-                status="error",
-                output=(
-                    f"File content ({size_kb:.1f}KB) exceeds maximum allowed size ({max_kb}KB). Please use offset and limit parameters to read specific portions of the file, or use the `rg` command to search for specific content."
-                ),
-            )
-
         offset = 1 if args.offset is None or args.offset < 1 else int(args.offset)
         limit = None if args.limit is None else int(args.limit)
         if limit is not None and limit < 0:
             limit = 0
 
-        # Stream file line-by-line and build response
-        read_result: ReadSegmentResult | None = None
-
         try:
             read_result = await asyncio.to_thread(
                 _read_segment,
@@ -292,6 +264,7 @@ class ReadTool(ToolABC):
                     limit=limit,
                     char_limit_per_line=char_per_line,
                     global_line_cap=line_cap,
+                    max_total_chars=max_chars,
                 ),
             )
 
@@ -306,40 +279,26 @@ class ReadTool(ToolABC):
                 output="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
             )
 
-        # If offset beyond total lines, emit system reminder warning
         if offset > max(read_result.total_lines, 0):
             warn = f"<system-reminder>Warning: the file exists but is shorter than the provided offset ({offset}). The file has {read_result.total_lines} lines.</system-reminder>"
-            # Update FileTracker (we still consider it as a read attempt)
-            _track_file_access(file_path)
+            _track_file_access(file_path, content_sha256=read_result.content_sha256)
             return model.ToolResultItem(status="success", output=warn)
 
-        # After limit/offset, if total selected chars exceed limit, error (only check if limits are enabled)
-        if max_chars is not None and read_result.selected_chars_count > max_chars:
-            # Build segment statistics for better guidance
-            stats_lines: list[str] = []
-            for start, end, chars in read_result.segment_char_stats:
-                stats_lines.append(f"  Lines {start}-{end}: {chars} chars")
-            segment_stats_str = "\n".join(stats_lines) if stats_lines else "  (no segment data)"
+        lines_out: list[str] = [_format_numbered_line(no, content) for no, content in read_result.selected_lines]
 
-            return model.ToolResultItem(
-                status="error",
-                output=(
-                    f"Selected file content {read_result.selected_chars_count} chars exceeds maximum allowed chars ({max_chars}).\n"
-                    f"File has {read_result.total_lines} total lines.\n\n"
-                    f"Character distribution by segment:\n{segment_stats_str}\n\n"
-                    f"Use offset and limit parameters to read specific portions. "
-                    f"For example: offset=1, limit=100 to read the first 100 lines. "
-                    f"Or use `rg` command to search for specific content."
-                ),
+        # Show truncation info with reason
+        if read_result.remaining_due_to_char_limit > 0:
+            lines_out.append(
+                f"... ({read_result.remaining_due_to_char_limit} more lines truncated due to {max_chars} char limit, "
+                f"file has {read_result.total_lines} lines total, use offset/limit to read other parts)"
+            )
+        elif read_result.remaining_selected_beyond_cap > 0:
+            lines_out.append(
+                f"... ({read_result.remaining_selected_beyond_cap} more lines truncated due to {line_cap} line limit, "
+                f"file has {read_result.total_lines} lines total, use offset/limit to read other parts)"
             )
 
-        # Build display with numbering and reminders
-        lines_out: list[str] = [_format_numbered_line(no, content) for no, content in read_result.selected_lines]
-        if read_result.remaining_selected_beyond_cap > 0:
-            lines_out.append(f"... (more {read_result.remaining_selected_beyond_cap} lines are truncated)")
         read_result_str = "\n".join(lines_out)
-
-        # Update FileTracker with last modified time
-        _track_file_access(file_path)
+        _track_file_access(file_path, content_sha256=read_result.content_sha256)
 
         return model.ToolResultItem(status="success", output=read_result_str)

klaude_code/core/tool/file/write_tool.py

@@ -2,13 +2,13 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
-import difflib
 import os
 from pathlib import Path
 
 from pydantic import BaseModel
 
-from klaude_code.core.tool.file._utils import file_exists, is_directory, read_text, write_text
+from klaude_code.core.tool.file._utils import file_exists, hash_text_sha256, is_directory, read_text, write_text
+from klaude_code.core.tool.file.diff_builder import build_structured_diff
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_context import get_current_file_tracker
 from klaude_code.core.tool.tool_registry import register
@@ -62,36 +62,52 @@ class WriteTool(ToolABC):
 
         file_tracker = get_current_file_tracker()
         exists = file_exists(file_path)
+        tracked_status: model.FileStatus | None = None
 
         if exists:
-            tracked_status: model.FileStatus | None = None
-            if file_tracker is not None:
-                tracked_status = file_tracker.get(file_path)
+            tracked_status = file_tracker.get(file_path) if file_tracker is not None else None
             if tracked_status is None:
                 return model.ToolResultItem(
                     status="error",
                     output=("File has not been read yet. Read it first before writing to it."),
                 )
-            try:
-                current_mtime = Path(file_path).stat().st_mtime
-            except Exception:
-                current_mtime = tracked_status.mtime
-            if current_mtime != tracked_status.mtime:
-                return model.ToolResultItem(
-                    status="error",
-                    output=(
-                        "File has been modified externally. Either by user or a linter. "
-                        "Read it first before writing to it."
-                    ),
-                )
 
-        # Capture previous content (if any) for diff generation
+        # Capture previous content (if any) for diff generation and external-change detection.
         before = ""
+        before_read_ok = False
         if exists:
             try:
                 before = await asyncio.to_thread(read_text, file_path)
+                before_read_ok = True
             except Exception:
                 before = ""
+                before_read_ok = False
+
+            # Re-check external modifications using content hash when available.
+            if before_read_ok and tracked_status is not None and tracked_status.content_sha256 is not None:
+                current_sha256 = hash_text_sha256(before)
+                if current_sha256 != tracked_status.content_sha256:
+                    return model.ToolResultItem(
+                        status="error",
+                        output=(
+                            "File has been modified externally. Either by user or a linter. "
+                            "Read it first before writing to it."
+                        ),
+                    )
+            elif tracked_status is not None:
+                # Backward-compat: old sessions only stored mtime, or we couldn't hash.
+                try:
+                    current_mtime = Path(file_path).stat().st_mtime
+                except Exception:
+                    current_mtime = tracked_status.mtime
+                if current_mtime != tracked_status.mtime:
+                    return model.ToolResultItem(
+                        status="error",
+                        output=(
+                            "File has been modified externally. Either by user or a linter. "
+                            "Read it first before writing to it."
+                        ),
+                    )
 
         try:
             await asyncio.to_thread(write_text, file_path, args.content)
@@ -102,21 +118,15 @@ class WriteTool(ToolABC):
             with contextlib.suppress(Exception):
                 existing = file_tracker.get(file_path)
                 is_mem = existing.is_memory if existing else False
-                file_tracker[file_path] = model.FileStatus(mtime=Path(file_path).stat().st_mtime, is_memory=is_mem)
+                file_tracker[file_path] = model.FileStatus(
+                    mtime=Path(file_path).stat().st_mtime,
+                    content_sha256=hash_text_sha256(args.content),
+                    is_memory=is_mem,
+                )
 
         # Build diff between previous and new content
         after = args.content
-        diff_lines = list(
-            difflib.unified_diff(
-                before.splitlines(),
-                after.splitlines(),
-                fromfile=file_path,
-                tofile=file_path,
-                n=3,
-            )
-        )
-        diff_text = "\n".join(diff_lines)
-        ui_extra = model.DiffTextUIExtra(diff_text=diff_text)
+        ui_extra = build_structured_diff(before, after, 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/core/tool/shell/bash_tool.py

@@ -2,6 +2,7 @@ import asyncio
 import contextlib
 import os
 import re
+import shlex
 import signal
 import subprocess
 from pathlib import Path
@@ -12,6 +13,7 @@ from pydantic import BaseModel
 from klaude_code import const
 from klaude_code.core.tool.shell.command_safety import is_safe_command
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
+from klaude_code.core.tool.tool_context import get_current_file_tracker
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
@@ -117,6 +119,149 @@ class BashTool(ToolABC):
             }
         )
 
+        def _hash_file_content_sha256(file_path: str) -> str | None:
+            try:
+                suffix = Path(file_path).suffix.lower()
+                if suffix in {".png", ".jpg", ".jpeg", ".gif", ".webp"}:
+                    import hashlib
+
+                    with open(file_path, "rb") as f:
+                        return hashlib.sha256(f.read()).hexdigest()
+
+                import hashlib
+
+                hasher = hashlib.sha256()
+                with open(file_path, encoding="utf-8", errors="replace") as f:
+                    for line in f:
+                        hasher.update(line.encode("utf-8"))
+                return hasher.hexdigest()
+            except (FileNotFoundError, IsADirectoryError, OSError, PermissionError, UnicodeDecodeError):
+                return None
+
+        def _resolve_in_dir(base_dir: str, path: str) -> str:
+            if os.path.isabs(path):
+                return os.path.abspath(path)
+            return os.path.abspath(os.path.join(base_dir, path))
+
+        def _track_files_read(file_paths: list[str], *, base_dir: str) -> None:
+            file_tracker = get_current_file_tracker()
+            if file_tracker is None:
+                return
+            for p in file_paths:
+                abs_path = _resolve_in_dir(base_dir, p)
+                if not os.path.exists(abs_path) or os.path.isdir(abs_path):
+                    continue
+                sha = _hash_file_content_sha256(abs_path)
+                if sha is None:
+                    continue
+                existing = file_tracker.get(abs_path)
+                is_mem = existing.is_memory if existing else False
+                with contextlib.suppress(Exception):
+                    file_tracker[abs_path] = model.FileStatus(
+                        mtime=Path(abs_path).stat().st_mtime,
+                        content_sha256=sha,
+                        is_memory=is_mem,
+                    )
+
+        def _track_files_written(file_paths: list[str], *, base_dir: str) -> None:
+            # Same as read tracking, but intentionally kept separate for clarity.
+            _track_files_read(file_paths, base_dir=base_dir)
+
+        def _track_mv(src_paths: list[str], dest_path: str, *, base_dir: str) -> None:
+            file_tracker = get_current_file_tracker()
+            if file_tracker is None:
+                return
+
+            abs_dest = _resolve_in_dir(base_dir, dest_path)
+            dest_is_dir = os.path.isdir(abs_dest)
+
+            for src in src_paths:
+                abs_src = _resolve_in_dir(base_dir, src)
+                abs_new = os.path.join(abs_dest, os.path.basename(abs_src)) if dest_is_dir else abs_dest
+
+                # Remove old entry if present.
+                existing = file_tracker.pop(abs_src, None)
+                is_mem = existing.is_memory if existing else False
+
+                if not os.path.exists(abs_new) or os.path.isdir(abs_new):
+                    continue
+
+                sha = _hash_file_content_sha256(abs_new)
+                if sha is None:
+                    continue
+                with contextlib.suppress(Exception):
+                    file_tracker[abs_new] = model.FileStatus(
+                        mtime=Path(abs_new).stat().st_mtime,
+                        content_sha256=sha,
+                        is_memory=is_mem,
+                    )
+
+        def _best_effort_update_file_tracker(command: str) -> None:
+            # Best-effort heuristics for common shell tools that access/modify files.
+            # We intentionally do not try to interpret complex shell scripts here.
+            try:
+                argv = shlex.split(command, posix=True)
+            except ValueError:
+                return
+            if not argv:
+                return
+
+            # Handle common patterns like: cd subdir && cat file
+            base_dir = os.getcwd()
+            while len(argv) >= 4 and argv[0] == "cd" and argv[2] == "&&":
+                dest = argv[1]
+                if dest != "-":
+                    base_dir = _resolve_in_dir(base_dir, dest)
+                argv = argv[3:]
+                if not argv:
+                    return
+
+            cmd0 = argv[0]
+            if cmd0 == "cat":
+                paths = [a for a in argv[1:] if a and not a.startswith("-") and a != "-"]
+                _track_files_read(paths, base_dir=base_dir)
+                return
+
+            if cmd0 == "sed":
+                # Support: sed [-i ...] 's/old/new/' file1 [file2 ...]
+                # and: sed -n 'Np' file
+                saw_script = False
+                file_paths: list[str] = []
+                for a in argv[1:]:
+                    if not a:
+                        continue
+                    if a == "--":
+                        continue
+                    if a.startswith("-") and not saw_script:
+                        continue
+                    if not saw_script and (a.startswith("s/") or a.startswith("s|") or a.endswith("p")):
+                        saw_script = True
+                        continue
+                    if saw_script and not a.startswith("-"):
+                        file_paths.append(a)
+
+                if file_paths:
+                    _track_files_written(file_paths, base_dir=base_dir)
+                return
+
+            if cmd0 == "mv":
+                # Support: mv [opts] src... dest
+                operands: list[str] = []
+                end_of_opts = False
+                for a in argv[1:]:
+                    if not end_of_opts and a == "--":
+                        end_of_opts = True
+                        continue
+                    if not end_of_opts and a.startswith("-"):
+                        continue
+                    operands.append(a)
+                if len(operands) < 2:
+                    return
+                srcs = operands[:-1]
+                dest = operands[-1]
+                _track_mv(srcs, dest, base_dir=base_dir)
+                return
+
         async def _terminate_process(proc: asyncio.subprocess.Process) -> None:
             # Best-effort termination. Ensure we don't hang on cancellation.
             if proc.returncode is not None:
@@ -185,6 +330,8 @@ class BashTool(ToolABC):
                 # Include stderr if there is useful diagnostics despite success
                 if stderr.strip():
                     output = (output + ("\n" if output else "")) + f"[stderr]\n{stderr}"
+
+                _best_effort_update_file_tracker(args.command)
                 return model.ToolResultItem(
                     status="success",
                     output=output.strip(),

klaude_code/core/tool/{memory → 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}

klaude_code/protocol/commands.py

@@ -4,7 +4,6 @@ from enum import Enum
 class CommandName(str, Enum):
     INIT = "init"
     DEBUG = "debug"
-    DIFF = "diff"
     HELP = "help"
     MODEL = "model"
     COMPACT = "compact"