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

klaude_code/protocol/model.py

@@ -70,9 +70,15 @@ class TodoItem(BaseModel):
 
 
 class FileStatus(BaseModel):
-    """Tracks file state including modification time and memory file flag."""
+    """Tracks file state including modification time and content hash.
+
+    Notes:
+    - `mtime` is a cheap heuristic and may miss changes on some filesystems.
+    - `content_sha256` provides an explicit content-based change detector.
+    """
 
     mtime: float
+    content_sha256: str | None = None
     is_memory: bool = False
 
 
@@ -86,9 +92,27 @@ class ToolSideEffect(str, Enum):
 
 
 # Discriminated union types for ToolResultUIExtra
-class DiffTextUIExtra(BaseModel):
-    type: Literal["diff_text"] = "diff_text"
-    diff_text: str
+class DiffSpan(BaseModel):
+    op: Literal["equal", "insert", "delete"]
+    text: str
+
+
+class DiffLine(BaseModel):
+    kind: Literal["ctx", "add", "remove", "gap"]
+    new_line_no: int | None = None
+    spans: list[DiffSpan]
+
+
+class DiffFileDiff(BaseModel):
+    file_path: str
+    lines: list[DiffLine]
+    stats_add: int = 0
+    stats_remove: int = 0
+
+
+class DiffUIExtra(BaseModel):
+    type: Literal["diff"] = "diff"
+    files: list[DiffFileDiff]
 
 
 class TodoListUIExtra(BaseModel):
@@ -122,12 +146,7 @@ class SessionStatusUIExtra(BaseModel):
 
 
 ToolResultUIExtra = Annotated[
-    DiffTextUIExtra
-    | TodoListUIExtra
-    | SessionIdUIExtra
-    | MermaidLinkUIExtra
-    | TruncationUIExtra
-    | SessionStatusUIExtra,
+    DiffUIExtra | TodoListUIExtra | SessionIdUIExtra | MermaidLinkUIExtra | TruncationUIExtra | SessionStatusUIExtra,
     Field(discriminator="type"),
 ]
 
@@ -211,6 +230,7 @@ class DeveloperMessageItem(BaseModel):
     at_files: list[AtPatternParseResult] | None = None
     command_output: CommandOutput | None = None
     user_image_count: int | None = None
+    skill_name: str | None = None  # Skill name activated via $skill syntax
 
 
 class ImageURLPart(BaseModel):
@@ -398,7 +418,7 @@ class TaskMetadata(BaseModel):
 class TaskMetadataItem(BaseModel):
     """Aggregated metadata for a complete task, stored in conversation history."""
 
-    main: TaskMetadata = Field(default_factory=TaskMetadata)
+    main_agent: TaskMetadata = Field(default_factory=TaskMetadata)  # Main agent metadata
     sub_agent_task_metadata: list[TaskMetadata] = Field(default_factory=lambda: list[TaskMetadata]())
     created_at: datetime = Field(default_factory=datetime.now)
 

klaude_code/protocol/tools.py

@@ -1,14 +1,13 @@
 BASH = "Bash"
 APPLY_PATCH = "apply_patch"
 EDIT = "Edit"
-MULTI_EDIT = "MultiEdit"
+
 READ = "Read"
 WRITE = "Write"
 TODO_WRITE = "TodoWrite"
 UPDATE_PLAN = "update_plan"
 SKILL = "Skill"
 MERMAID = "Mermaid"
-MEMORY = "Memory"
 WEB_FETCH = "WebFetch"
 WEB_SEARCH = "WebSearch"
 REPORT_BACK = "report_back"

klaude_code/session/export.py

@@ -235,7 +235,7 @@ def _render_metadata_item(item: model.TaskMetadataItem) -> str:
     lines: list[str] = []
 
     # Main agent metadata
-    lines.append(_render_single_metadata(item.main, indent=0, show_context=True))
+    lines.append(_render_single_metadata(item.main_agent, indent=0, show_context=True))
 
     # Sub-agent metadata with indent
     for sub in item.sub_agent_task_metadata:
@@ -362,33 +362,87 @@ def _should_collapse(text: str) -> bool:
     return text.count("\n") + 1 > _COLLAPSIBLE_LINE_THRESHOLD or len(text) > _COLLAPSIBLE_CHAR_THRESHOLD
 
 
-def _render_diff_block(diff: str) -> str:
-    lines = diff.splitlines()
+def _render_diff_block(diff: model.DiffUIExtra) -> str:
     rendered: list[str] = []
-    for line in lines:
-        escaped = _escape_html(line)
-        if line.startswith("+"):
-            rendered.append(f'<span class="diff-line diff-plus">{escaped}</span>')
-        elif line.startswith("-"):
-            rendered.append(f'<span class="diff-line diff-minus">{escaped}</span>')
-        else:
-            rendered.append(f'<span class="diff-line diff-ctx">{escaped}</span>')
+    line_count = 0
+
+    for file_diff in diff.files:
+        header = _render_diff_file_header(file_diff)
+        if header:
+            rendered.append(header)
+        for line in file_diff.lines:
+            rendered.append(_render_diff_line(line))
+            line_count += 1
+
+    if line_count == 0:
+        rendered.append('<span class="diff-line diff-ctx">&nbsp;</span>')
+
     diff_content = f'<div class="diff-view">{"".join(rendered)}</div>'
-    open_attr = "" if _should_collapse(diff) else " open"
+    open_attr = "" if _should_collapse("\n" * max(1, line_count)) else " open"
     return (
         f'<details class="diff-collapsible"{open_attr}>'
-        f"<summary>Diff ({len(lines)} lines)</summary>"
+        f"<summary>Diff ({line_count} lines)</summary>"
         f"{diff_content}"
         "</details>"
     )
 
 
-def _get_diff_text(ui_extra: model.ToolResultUIExtra | None) -> str | None:
-    if isinstance(ui_extra, model.DiffTextUIExtra):
-        return ui_extra.diff_text
+def _render_diff_file_header(file_diff: model.DiffFileDiff) -> str:
+    stats_parts: list[str] = []
+    if file_diff.stats_add > 0:
+        stats_parts.append(f'<span class="diff-stats-add">+{file_diff.stats_add}</span>')
+    if file_diff.stats_remove > 0:
+        stats_parts.append(f'<span class="diff-stats-remove">-{file_diff.stats_remove}</span>')
+    stats_html = f' <span class="diff-stats">{" ".join(stats_parts)}</span>' if stats_parts else ""
+    file_name = _escape_html(file_diff.file_path)
+    return f'<div class="diff-file">{file_name}{stats_html}</div>'
+
+
+def _render_diff_line(line: model.DiffLine) -> str:
+    if line.kind == "gap":
+        line_class = "diff-ctx"
+        prefix = "⋮"
+    else:
+        line_class = "diff-plus" if line.kind == "add" else "diff-minus" if line.kind == "remove" else "diff-ctx"
+        prefix = "+" if line.kind == "add" else "-" if line.kind == "remove" else " "
+    spans = [_render_diff_span(span, line.kind) for span in line.spans]
+    content = "".join(spans)
+    if not content:
+        content = "&nbsp;"
+    return f'<span class="diff-line {line_class}">{prefix} {content}</span>'
+
+
+def _render_diff_span(span: model.DiffSpan, line_kind: str) -> str:
+    text = _escape_html(span.text)
+    if line_kind == "add" and span.op == "insert":
+        return f'<span class="diff-span diff-char-add">{text}</span>'
+    if line_kind == "remove" and span.op == "delete":
+        return f'<span class="diff-span diff-char-remove">{text}</span>'
+    return f'<span class="diff-span">{text}</span>'
+
+
+def _get_diff_ui_extra(ui_extra: model.ToolResultUIExtra | None) -> model.DiffUIExtra | None:
+    if isinstance(ui_extra, model.DiffUIExtra):
+        return ui_extra
     return None
 
 
+def _build_add_only_diff(text: str, file_path: str) -> model.DiffUIExtra:
+    lines: list[model.DiffLine] = []
+    new_line_no = 1
+    for line in text.splitlines():
+        lines.append(
+            model.DiffLine(
+                kind="add",
+                new_line_no=new_line_no,
+                spans=[model.DiffSpan(op="equal", text=line)],
+            )
+        )
+        new_line_no += 1
+    file_diff = model.DiffFileDiff(file_path=file_path, lines=lines, stats_add=len(lines), stats_remove=0)
+    return model.DiffUIExtra(files=[file_diff])
+
+
 def _get_mermaid_link_html(
     ui_extra: model.ToolResultUIExtra | None, tool_call: model.ToolCallItem | None = None
 ) -> str | None:
@@ -513,18 +567,19 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
     ]
 
     if result:
-        diff_text = _get_diff_text(result.ui_extra)
+        diff_ui = _get_diff_ui_extra(result.ui_extra)
         mermaid_html = _get_mermaid_link_html(result.ui_extra, tool_call)
 
         should_hide_text = tool_call.name in ("TodoWrite", "update_plan") and result.status != "error"
 
-        if tool_call.name == "Edit" and not diff_text and result.status != "error":
+        if tool_call.name == "Edit" and not diff_ui and result.status != "error":
             try:
                 args_data = json.loads(tool_call.arguments)
+                file_path = args_data.get("file_path", "Unknown file")
                 old_string = args_data.get("old_string", "")
                 new_string = args_data.get("new_string", "")
                 if old_string == "" and new_string:
-                    diff_text = "\n".join(f"+{line}" for line in new_string.splitlines())
+                    diff_ui = _build_add_only_diff(new_string, file_path)
             except (json.JSONDecodeError, TypeError):
                 pass
 
@@ -536,8 +591,8 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
             else:
                 items_to_render.append(_render_text_block(result.output))
 
-        if diff_text:
-            items_to_render.append(_render_diff_block(diff_text))
+        if diff_ui:
+            items_to_render.append(_render_diff_block(diff_ui))
 
         if mermaid_html:
             items_to_render.append(mermaid_html)

klaude_code/session/store.py

@@ -205,11 +205,13 @@ def build_meta_snapshot(
         "work_dir": str(work_dir),
         "sub_agent_state": sub_agent_state.model_dump(mode="json") if sub_agent_state else None,
         "file_tracker": {path: status.model_dump(mode="json") for path, status in file_tracker.items()},
-        "todos": [todo.model_dump(mode="json") for todo in todos],
+        "todos": [todo.model_dump(mode="json", exclude_defaults=True) for todo in todos],
         "created_at": created_at,
         "updated_at": updated_at,
         "messages_count": messages_count,
         "model_name": model_name,
         "model_config_name": model_config_name,
-        "model_thinking": model_thinking.model_dump(mode="json") if model_thinking else None,
+        "model_thinking": model_thinking.model_dump(mode="json", exclude_defaults=True, exclude_none=True)
+        if model_thinking
+        else None,
     }

klaude_code/session/templates/export_session.html

@@ -31,6 +31,8 @@
         --bg-overlay: rgba(248, 246, 240, 0.98);
         --bg-error: #fdecec;
         --bg-success: #eaf6ed;
+        --bg-error-strong: #f9d6d6;
+        --bg-success-strong: #d5efdd;
         --bg-code: #f7f7f4;
         --border: #ded8cf;
         --text: #151515;
@@ -815,6 +817,21 @@
         overflow-x: auto;
         border: 1px solid var(--border);
       }
+      .diff-file {
+        color: var(--accent);
+        font-weight: 700;
+        margin: 6px 0 4px 0;
+        font-size: var(--font-size-sm);
+      }
+      .diff-stats {
+        font-weight: 600;
+      }
+      .diff-stats-add {
+        color: var(--success);
+      }
+      .diff-stats-remove {
+        color: var(--error);
+      }
       .diff-line {
         white-space: pre;
       }
@@ -833,6 +850,17 @@
         opacity: 0.7;
         display: block;
       }
+      .diff-span {
+        white-space: pre;
+      }
+      .diff-char-add {
+        background: var(--bg-success-strong);
+        font-weight: 600;
+      }
+      .diff-char-remove {
+        background: var(--bg-error-strong);
+        font-weight: 600;
+      }
 
       /* Collapsible Diff View */
       details.diff-collapsible {

klaude_code/skill/__init__.py

@@ -0,0 +1,27 @@
+"""Skill module - independent skill management system.
+
+This module provides the core skill functionality:
+- Skill discovery and loading from multiple directories
+- System skill installation
+- Global skill access via manager functions
+
+Public API:
+- get_skill(name) - Get a skill by name
+- get_available_skills() - Get list of (name, description, location) tuples
+- get_skill_loader() - Get the global SkillLoader instance
+- list_skill_names() - Get list of skill names
+- Skill - Skill data class
+- SkillLoader - Skill loader class
+"""
+
+from klaude_code.skill.loader import Skill, SkillLoader
+from klaude_code.skill.manager import get_available_skills, get_skill, get_skill_loader, list_skill_names
+
+__all__ = [
+    "Skill",
+    "SkillLoader",
+    "get_available_skills",
+    "get_skill",
+    "get_skill_loader",
+    "list_skill_names",
+]

klaude_code/skill/assets/deslop/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: deslop
+description: Remove AI-generated code slop from files or diffs. Use this skill when reviewing AI-generated code to clean up unnecessary comments, defensive code, type hacks, and style inconsistencies. Triggers include "deslop", "remove slop", "clean up AI code", "review for slop".
+metadata:
+  short-description: Remove AI code slop
+---
+
+# Deslop
+
+Remove AI-generated slop from code. Check the specified files or diff and remove:
+
+- Extra comments that a human wouldn't add or are inconsistent with the rest of the file
+- Extra defensive checks or try/catch blocks that are abnormal for that area of the codebase (especially if called by trusted/validated codepaths)
+- Casts to `any` or `# type: ignore` to get around type issues
+- Any other style that is inconsistent with the file
+
+Report at the end with only a 1-3 sentence summary of what you changed.

klaude_code/skill/assets/dev-docs/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: dev-docs
+description: Manage development documentation for complex tasks. Use this skill when users want to create a strategic plan with structured task breakdown, or update development documentation before context compaction/reset. Triggers include "create a plan", "dev docs", "update docs before context reset", "context limit approaching".
+metadata:
+  short-description: Create and update development documentation
+---
+
+# Dev Docs
+
+Manage development documentation for complex, multi-phase tasks. This skill supports two workflows:
+1. **Create**: Generate a comprehensive strategic plan with structured task breakdown
+2. **Update**: Update documentation before context compaction or reset
+
+## Create Development Plan
+
+When creating a new plan:
+
+1. **Analyze the request** and determine the scope of planning needed
+2. **Examine relevant files** in the codebase to understand current state
+3. **Create a structured plan** with:
+   - Executive Summary
+   - Current State Analysis
+   - Proposed Future State
+   - Implementation Phases (broken into sections)
+   - Detailed Tasks (actionable items with clear acceptance criteria)
+   - Risk Assessment and Mitigation Strategies
+   - Success Metrics
+   - Required Resources and Dependencies
+
+4. **Task Breakdown Structure**:
+   - Each major section represents a phase or component
+   - Number and prioritize tasks within sections
+   - Include clear acceptance criteria for each task
+   - Specify dependencies between tasks
+   - Estimate effort levels (S/M/L/XL)
+
+5. **Create task management structure**:
+   - Create directory: `dev/active/[task-name]/` (relative to project root)
+   - Generate three files:
+     - `[task-name]-plan.md` - The comprehensive plan
+     - `[task-name]-context.md` - Key files, decisions, dependencies
+     - `[task-name]-tasks.md` - Checklist format for tracking progress
+   - Include "Last Updated: YYYY-MM-DD" in each file
+
+6. **Stop and Consult**: Pause and negotiate the plan with the user.
+
+### Quality Standards
+
+- Plans must be self-contained with all necessary context
+- Use clear, actionable language
+- Include specific technical details where relevant
+- Consider both technical and business perspectives
+- Account for potential risks and edge cases
+
+## Update Development Documentation
+
+When approaching context limits or before context reset:
+
+### 1. Update Active Task Documentation
+
+For each task in `/dev/active/`:
+
+Update `[task-name]-context.md` with:
+- Current implementation state
+- Key decisions made this session
+- Files modified and why
+- Any blockers or issues discovered
+- Next immediate steps
+- Last Updated timestamp
+
+Update `[task-name]-tasks.md` with:
+- Mark completed tasks with checkmark
+- Add any new tasks discovered
+- Update in-progress tasks with current status
+- Reorder priorities if needed
+
+### 2. Capture Session Context
+
+Include any relevant information about:
+- Complex problems solved
+- Architectural decisions made
+- Tricky bugs found and fixed
+- Integration points discovered
+- Testing approaches used
+- Performance optimizations made
+
+### 3. Update Memory (if applicable)
+
+- Store any new patterns or solutions in project memory/documentation
+- Update entity relationships discovered
+- Add observations about system behavior
+
+### 4. Document Unfinished Work
+
+- What was being worked on when context limit approached
+- Exact state of any partially completed features
+- Commands that need to be run on restart
+- Any temporary workarounds that need permanent fixes
+
+### 5. Create Handoff Notes
+
+If switching to a new conversation:
+- Exact file and line being edited
+- The goal of current changes
+- Any uncommitted changes that need attention
+- Test commands to verify work
+
+**Priority**: Focus on capturing information that would be hard to rediscover or reconstruct from code alone.

klaude_code/skill/assets/handoff/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: handoff
+description: Write a HANDOFF.md file for another agent to continue the conversation. Use this skill when switching to a new conversation/session and need to pass context to the next agent. Triggers include "handoff", "write handoff", "create handoff", "pass to another agent".
+metadata:
+  short-description: Write handoff document for agent continuation
+---
+
+# Handoff
+
+Write a HANDOFF.md file in the current working directory for another agent to continue this conversation.
+
+Extract relevant context from the conversation to facilitate continuing this work. Write from the user's perspective (first person: "I did...", "I told you...").
+
+## Consider What Would Be Useful
+
+- What did the user just do or implement?
+- What instructions did the user give that are still relevant (e.g., follow patterns in the codebase)?
+- Did the user provide a plan or spec that should be included?
+- What important information did the user share (certain libraries, patterns, constraints, preferences)?
+- What key technical details were discovered (APIs, methods, patterns)?
+- What caveats, limitations, or open questions remain?
+
+Extract only what matters for the specific goal. Skip irrelevant questions. Choose an appropriate length based on the complexity.
+
+Focus on capabilities and behavior, not file-by-file changes. Avoid excessive implementation details (variable names, storage keys, constants) unless critical.
+
+## Format
+
+- Plain text with bullets
+- No markdown headers, no bold/italic, no code fences
+- Use workspace-relative paths for files
+- List relevant file or directory paths at the end:
+
+```
+@src/project/main.py
+@src/project/llm/
+```
+
+If the user's goal is unclear, ask for clarification.

klaude_code/skill/assets/jj-workspace/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: jj-workspace
+description: Create a jj workspace before starting work to enable parallel Claude sessions. Use this skill when starting a new task that should be isolated from other concurrent work. Triggers include "jj workspace", "parallel work", "create workspace", "isolated workspace".
+metadata:
+  short-description: Create jj workspace for parallel work
+---
+
+# JJ Workspace
+
+Create a dedicated jj workspace before starting any task. This allows multiple Claude sessions to work in parallel without conflicts.
+
+## Steps
+
+1. Generate a short, descriptive workspace name based on the task (e.g., `workspace-add-login` or `workspace-fix-typo`)
+2. Run `jj workspace add <workspace-name>` to create the workspace
+3. Change into the workspace directory: `cd <workspace-name>`
+4. Describe the change: `jj describe -m '<brief task description>'`
+5. Continue all subsequent work within this workspace directory
+
+If no task is provided, ask the user for a task description.

klaude_code/skill/assets/skill-creator/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: skill-creator
+description: Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.
+metadata:
+  short-description: Create or update a skill
+---
+
+# Skill Creator
+
+This skill provides guidance for creating effective skills.
+
+## About Skills
+
+Skills are modular, self-contained packages that extend the agent's capabilities by providing
+specialized knowledge, workflows, and tools. Think of them as "onboarding guides" for specific
+domains or tasks - they transform the agent from a general-purpose assistant into a specialized
+agent equipped with procedural knowledge.
+
+### What Skills Provide
+
+1. Specialized workflows - Multi-step procedures for specific domains
+2. Tool integrations - Instructions for working with specific file formats or APIs
+3. Domain expertise - Company-specific knowledge, schemas, business logic
+4. Bundled resources - Scripts, references, and assets for complex and repetitive tasks
+
+## Core Principles
+
+### Concise is Key
+
+The context window is a public good. Skills share the context window with everything else:
+system prompt, conversation history, other Skills' metadata, and the actual user request.
+
+**Default assumption: The agent is already very smart.** Only add context the agent doesn't
+already have. Challenge each piece of information: "Does the agent really need this explanation?"
+and "Does this paragraph justify its token cost?"
+
+Prefer concise examples over verbose explanations.
+
+### Anatomy of a Skill
+
+Every skill consists of a required SKILL.md file and optional bundled resources:
+
+```
+skill-name/
+├── SKILL.md (required)
+│   ├── YAML frontmatter metadata (required)
+│   │   ├── name: (required)
+│   │   └── description: (required)
+│   └── Markdown instructions (required)
+└── Bundled Resources (optional)
+    ├── scripts/          - Executable code (Python/Bash/etc.)
+    ├── references/       - Documentation intended to be loaded into context as needed
+    └── assets/           - Files used in output (templates, icons, fonts, etc.)
+```
+
+#### SKILL.md (required)
+
+Every SKILL.md consists of:
+
+- **Frontmatter** (YAML): Contains `name` and `description` fields. These are the only fields
+  that determine when the skill gets used, thus it is very important to be clear and comprehensive
+  in describing what the skill is, and when it should be used.
+- **Body** (Markdown): Instructions and guidance for using the skill. Only loaded AFTER the
+  skill triggers (if at all).
+
+#### Bundled Resources (optional)
+
+##### Scripts (`scripts/`)
+
+Executable code (Python/Bash/etc.) for tasks that require deterministic reliability or are
+repeatedly rewritten.
+
+- **When to include**: When the same code is being rewritten repeatedly or deterministic
+  reliability is needed
+- **Example**: `scripts/rotate_pdf.py` for PDF rotation tasks
+- **Benefits**: Token efficient, deterministic, may be executed without loading into context
+
+##### References (`references/`)
+
+Documentation and reference material intended to be loaded as needed into context.
+
+- **When to include**: For documentation that the agent should reference while working
+- **Examples**: `references/schema.md` for database schemas, `references/api_docs.md` for
+  API specifications
+- **Benefits**: Keeps SKILL.md lean, loaded only when needed
+
+##### Assets (`assets/`)
+
+Files not intended to be loaded into context, but rather used within the output.
+
+- **When to include**: When the skill needs files that will be used in the final output
+- **Examples**: `assets/logo.png` for brand assets, `assets/template.html` for HTML templates
+- **Benefits**: Separates output resources from documentation
+
+## Skill Creation Process
+
+Skill creation involves these steps:
+
+1. Understand the skill with concrete examples
+2. Plan reusable skill contents (scripts, references, assets)
+3. Create the skill directory structure
+4. Write SKILL.md with proper frontmatter
+5. Add bundled resources as needed
+6. Test and iterate based on real usage
+
+### Skill Naming
+
+- Use lowercase letters, digits, and hyphens only
+- Prefer short, verb-led phrases that describe the action
+- Name the skill folder exactly after the skill name
+
+### Writing Guidelines
+
+Always use imperative/infinitive form.
+
+#### Frontmatter
+
+Write the YAML frontmatter with `name` and `description`:
+
+- `name`: The skill name (required)
+- `description`: This is the primary triggering mechanism for your skill. Include both what
+  the Skill does and specific triggers/contexts for when to use it. Include all "when to use"
+  information here - Not in the body.
+
+#### Body
+
+Write instructions for using the skill and its bundled resources. Keep SKILL.md body to the
+essentials and under 500 lines to minimize context bloat.
+
+## Skill Storage Locations
+
+Skills can be stored in multiple locations with the following priority (higher priority overrides lower):
+
+| Priority | Scope   | Path                        | Description           |
+|----------|---------|-----------------------------|-----------------------|
+| 1        | Project | `.claude/skills/`           | Current project only  |
+| 2        | User    | `~/.klaude/skills/`         | User-level            |
+| 3        | User    | `~/.claude/skills/`         | User-level (Claude)   |
+| 4        | System  | `~/.klaude/skills/.system/` | Built-in system skills|