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

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/const/__init__.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 = 20
 
 
 # UI refresh rate (frames per second) for debounced content streaming
@@ -102,6 +102,12 @@ 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)"
 

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/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/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/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/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/model.py

@@ -230,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):
@@ -417,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/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:

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/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.