clavix 4.2.0 → 4.3.2

package/dist/templates/slash-commands/_canonical 2/implement.md

@@ -1,364 +0,0 @@
----
-name: "Clavix: Implement"
-description: Execute tasks from the implementation plan
----
-
-# Clavix Implement - AI-Assisted Task Execution
-
-You are helping the user implement tasks from their task plan with AI assistance.
-
-## Instructions
-
-1. **First-time setup - Run CLI command with optional git strategy**:
-
-   Check if `.clavix-implement-config.json` exists in the PRD output folder.
-
-   **If config file does NOT exist** (first time running implement):
-
-   a. **Check if user wants git auto-commits** (optional, only if tasks.md has >3 phases):
-      ```
-      "I notice this implementation has [X] phases with [Y] tasks total.
-
-      Would you like me to create git commits automatically as I complete tasks?
-
-      Options:
-      - per-task: Commit after each task (frequent commits, detailed history)
-      - per-5-tasks: Commit every 5 tasks (balanced approach)
-      - per-phase: Commit when each phase completes (milestone commits)
-      - none: Manual git workflow (I won't create commits)
-
-      Please choose one, or I'll proceed with 'none' (manual commits)."
-      ```
-
-   b. **Run the CLI command to initialize**:
-      ```bash
-      # With git strategy (if user specified):
-      clavix implement --commit-strategy=per-phase
-
-      # Or without (defaults to 'none' - manual commits):
-      clavix implement
-      ```
-
-   c. **This will**:
-      - Show current progress
-      - Display the next incomplete task
-      - Create `.clavix-implement-config.json` file
-      - Set git auto-commit strategy (or default to 'none')
-
-   d. Wait for command to complete, then proceed with step 2
-
-   **If config file already exists**:
-   - Skip to step 2 (implementation loop)
-
-2. **As the AI agent, you should**:
-
-   a. **Read the configuration**:
-      - Load `.clavix-implement-config.json` from the PRD folder
-      - This contains: commit strategy, current task, and progress stats
-
-   b. **Read the PRD for context**:
-      - Open the full PRD to understand requirements
-      - Reference specific sections mentioned in tasks
-
-   c. **Read tasks.md**:
-      - Find the first incomplete task (marked `- [ ]`)
-      - This is your current task to implement
-
-   d. **Implement the task**:
-      - Write/modify code as needed
-      - Follow quality principles (clarity, structure, actionability)
-      - Use PRD requirements as your guide
-      - Ask user for clarification if needed
-
-   e. **Complete the task programmatically**:
-      - IMPORTANT: NEVER manually edit checkboxes in tasks.md
-      - Instead, run: `clavix task-complete {task-id}`
-      - The task ID is found in tasks.md (e.g., `phase-1-authentication-1`)
-      - This command automatically:
-        • Validates the task exists
-        • Updates the checkbox in tasks.md
-        • Tracks completion in config file
-        • Creates git commit (if strategy enabled)
-        • Displays the next task
-      - Example: `clavix task-complete phase-1-setup-1`
-
-   f. **Move to next task**:
-      - The task-complete command shows the next task automatically
-      - Read it and repeat the process
-      - If you get interrupted, just run `clavix implement` again to resume
-
-3. **Session Resume**:
-   - When user runs `clavix implement` again, it automatically picks up from the last incomplete task
-   - No manual tracking needed - the checkboxes in tasks.md are the source of truth
-
-## Task Completion Workflow
-
-**CRITICAL: Always use the `clavix task-complete` command**
-
-### Why task-complete is CLI-Only
-
-The `clavix task-complete` command requires:
-- State validation across config files
-- Atomic checkbox updates in tasks.md
-- Conditional git commit execution
-- Progress tracking and next-task resolution
-
-Therefore it's implemented as a **CLI command** (not a slash command) and called **automatically by the agent** during implementation workflow.
-
-**Agent Responsibility:** Run `clavix task-complete {task-id}` after implementing each task.
-**User Responsibility:** None - agent handles task completion automatically.
-
-### Usage
-
-```bash
-# After implementing a task, agent runs:
-clavix task-complete {task-id}
-
-# Example
-clavix task-complete phase-1-setup-1
-```
-
-The command handles:
-- Checkbox updates in tasks.md
-- Config file tracking
-- Git commits (per strategy)
-- Progress display
-- Next task retrieval
-
-**NEVER manually edit tasks.md checkboxes** - the command ensures proper tracking and prevents state inconsistencies.
-
-## Important Rules
-
-**DO**:
-- Read tasks.md to find the current task and its ID
-- Implement ONE task at a time
-- Use `clavix task-complete {task-id}` after completing each task
-- Reference the PRD for detailed requirements
-- Ask for clarification when tasks are ambiguous
-- Run `clavix implement` again if interrupted to resume
-
-**DON'T**:
-- NEVER manually edit checkboxes in tasks.md
-- Skip tasks or implement out of order
-- Mark tasks complete before actually implementing them
-- Assume what code to write - use PRD as source of truth
-- Try to track task completion manually
-
-## Task Blocking Protocol
-
-**When a task is blocked** (cannot be completed), follow this protocol:
-
-### Step 1: Detect Blocking Issues
-
-Common blocking scenarios:
-- **Missing dependencies**: API keys, credentials, external services not available
-- **Unclear requirements**: Task description too vague or conflicts with PRD
-- **External blockers**: Need design assets, content, or third-party integration not ready
-- **Technical blockers**: Required library incompatible, environment issue, access problem
-- **Resource blockers**: Need database, server, or infrastructure not yet set up
-
-### Step 2: Immediate User Communication
-
-**Stop implementation and ask user immediately:**
-```
-"Task blocked: [Task description]
-
-Blocking issue: [Specific blocker, e.g., 'Missing Stripe API key for payment integration']
-
-Options to proceed:
-1. **Provide missing resource** - [What user needs to provide]
-2. **Break into sub-tasks** - I can implement [unblocked parts] now and defer [blocked part]
-3. **Skip for now** - Mark as [BLOCKED], continue with next task, return later
-
-Which option would you like?"
-```
-
-### Step 3: Resolution Strategies
-
-**Option A: User Provides Resource**
-- Wait for user to provide (API key, design, clarification)
-- Once provided, continue with task implementation
-
-**Option B: Create Sub-Tasks** (preferred when possible)
-- Identify what CAN be done without the blocker
-- Break task into unblocked sub-tasks
-- Example: "Implement payment integration" →
-  - [x] Create payment service interface (can do now)
-  - [ ] [BLOCKED: Need Stripe API key] Integrate Stripe SDK
-  - [ ] Add payment UI components (can do now)
-- Implement unblocked sub-tasks, mark blocked ones with [BLOCKED] tag
-
-**Option C: Skip and Mark Blocked**
-- Add [BLOCKED] tag to task in tasks.md: `- [ ] [BLOCKED: Missing API key] Task description`
-- Note the blocker reason
-- Move to next task
-- Return to blocked tasks when unblocked
-
-### Step 4: Track Blocked Tasks
-
-**In tasks.md, use [BLOCKED] notation:**
-```markdown
-## Phase 2: Integration
-- [x] Create API client structure
-- [ ] [BLOCKED: Waiting for API endpoint spec] Implement data sync
-- [ ] Add error handling for API calls
-```
-
-**At end of implement session:**
-- List all blocked tasks
-- Remind user what's needed to unblock each one
-- Suggest next steps
-
-### Common Blocking Scenarios & Resolutions
-
-| Blocker Type | Detection | Resolution |
-|--------------|-----------|------------|
-| Missing API key/credentials | Code requires authentication | Ask user for credentials OR stub with mock for now |
-| Vague requirements | Unclear what to implement | Ask specific questions OR propose implementation for approval |
-| External dependency | Service/API not available | Create interface/mock OR skip and defer |
-| Environment issue | Can't run/test code | Ask user to fix environment OR implement without testing (note risk) |
-| Design/content missing | Need specific assets | Create placeholder OR wait for actual assets |
-
-## Example Workflow
-
-**CRITICAL WORKFLOW RULE:**
-- Agent implements task → Agent runs `clavix task-complete` → Agent proceeds to next task
-- User NEVER manually runs task-complete
-- User NEVER manually edits tasks.md checkboxes
-- This is an automated workflow, not a manual checklist
-
-```
-1. User runs: clavix implement
-2. Command shows: "Next task (ID: phase-1-auth-1): Implement user authentication"
-3. You (AI agent):
-   - Read PRD authentication requirements
-   - Implement auth logic
-   - Write tests
-   - Run: clavix task-complete phase-1-auth-1
-   - Command automatically:
-     • Marks task complete in tasks.md
-     • Updates config tracking
-     • Creates git commit (if enabled)
-     • Shows next task
-   - Continue with next task or wait for user
-```
-
-## Finding Task IDs
-
-Task IDs are visible in several places:
-1. When you read `tasks.md` - they're in the format `phase-X-name-Y`
-2. In the config file (`.clavix-implement-config.json`) under `currentTask.id`
-3. When running `clavix implement` - shown next to task description
-
-Example tasks.md structure:
-```markdown
-## Phase 1: Authentication
-
-- [ ] Implement user registration (ref: User Management)
-  Task ID: phase-1-authentication-1
-
-- [ ] Add JWT token generation (ref: User Management)
-  Task ID: phase-1-authentication-2
-```
-
-To find the task ID programmatically, read tasks.md and look for the pattern `phase-{number}-{sanitized-phase-name}-{counter}`.
-
-## Workflow Navigation
-
-**You are here:** Implement (Task Execution)
-
-**Common workflows:**
-- **Full workflow**: `/clavix:plan` → `/clavix:implement` → [execute all tasks] → `/clavix:archive`
-- **Resume work**: `/clavix:implement` → Continue from last incomplete task
-- **Iterative**: `/clavix:implement` → [complete task] → [pause] → `/clavix:implement` → [continue]
-
-**Related commands:**
-- `/clavix:plan` - Generate/regenerate task breakdown (previous step)
-- `/clavix:archive` - Archive completed project (final step)
-- `/clavix:prd` - Review PRD for context during implementation
-
-## Tips
-
-- The implementation is meant to be iterative and collaborative
-- User can pause/resume at any time
-- Tasks are designed to be atomic and independently implementable
-- Use the PRD as the authoritative source for "what to build"
-- Use tasks.md as the guide for "in what order"
-
-## Troubleshooting
-
-### Issue: `.clavix-implement-config.json` not found
-**Cause**: User hasn't run `clavix implement` CLI command first
-**Solution** (inline):
-- Error: "Config file not found. Run `clavix implement` first to initialize"
-- CLI creates config and shows first task
-- AI agent should wait for config before proceeding
-
-### Issue: `clavix task-complete` command not found
-**Cause**: Clavix version doesn't have task-complete command OR not in PATH
-**Solution**:
-- Check Clavix version: `clavix --version`
-- Ensure Clavix is up to date: `npm install -g clavix@latest`
-- If issue persists, report bug to Clavix maintainers
-
-### Issue: Task ID not found by task-complete
-**Cause**: Task ID doesn't match what's in tasks.md
-**Solution**:
-- Read tasks.md to see actual task IDs
-- Task IDs follow pattern: `{sanitized-phase-name}-{counter}`
-- Run `clavix task-complete` without arguments to see available tasks
-- Example: `phase-1-authentication-1` not `Phase 1 Authentication 1`
-
-### Issue: Task already marked complete
-**Cause**: Task was completed in previous session or manually
-**Solution**:
-- Use `--force` flag: `clavix task-complete {task-id} --force`
-- Or skip to next task shown by `clavix implement`
-- Config will be updated to track the completion
-
-### Issue: Cannot find next incomplete task in tasks.md
-**Cause**: All tasks completed OR tasks.md corrupted
-**Solution**:
-- Check if all tasks are `[x]` - if yes, congratulate completion!
-- Suggest `/clavix:archive` for completed project
-- If tasks.md corrupted, ask user to review/regenerate
-
-### Issue: Task description unclear or conflicts with PRD
-**Cause**: Task breakdown was too vague or PRD changed
-**Solution** (inline - covered by Task Blocking Protocol):
-- Stop and ask user for clarification
-- Reference PRD section if mentioned
-- Propose interpretation for user approval
-- Update task description in tasks.md after clarification
-
-### Issue: Git commit fails (wrong strategy, hook error, etc.)
-**Cause**: Git configuration issue or commit hook failure
-**Solution**:
-- Show error to user
-- Suggest checking git status manually
-- Ask if should continue without commit or fix issue first
-- Note: Commits are convenience, not blocker - can proceed without
-
-### Issue: Multiple [BLOCKED] tasks accumulating
-**Cause**: Dependencies or blockers not being resolved
-**Solution**:
-- After 3+ blocked tasks, pause and report to user
-- List all blockers and what's needed to resolve
-- Ask user to prioritize: unblock tasks OR continue with unblocked ones
-- Consider if project should be paused until blockers cleared
-
-### Issue: Task completed but tests failing
-**Cause**: Implementation doesn't meet requirements
-**Solution**:
-- Do NOT mark task as complete if tests fail
-- Fix failing tests before marking [x]
-- If tests are incorrectly written, fix tests first
-- Task isn't done until tests pass
-
-### Issue: Implementing in wrong order (skipped dependencies)
-**Cause**: AI agent or user jumped ahead
-**Solution**:
-- Stop and review tasks.md order
-- Check if skipped task was a dependency
-- Implement missed dependency first
-- Follow sequential order unless explicitly instructed otherwise

package/dist/templates/slash-commands/_canonical 2/plan.md

@@ -1,329 +0,0 @@
----
-name: "Clavix: Plan"
-description: Generate implementation task breakdown from PRD
----
-
-# Clavix Plan - Task Breakdown Generator
-
-You are helping the user generate an optimized implementation task breakdown from their PRD.
-
-## Instructions
-
-### Part A: Agent Execution Protocol
-
-**As an AI agent, you have two execution options:**
-
-#### **Option 1: Run CLI Command** (Recommended for most cases)
-
-1. **Validate prerequisites**:
-   - Check if `.clavix/outputs/` directory exists
-   - Look for PRD artifacts: `full-prd.md`, `quick-prd.md`, `mini-prd.md`, or `optimized-prompt.md`
-   - **If not found**: Error inline - "No PRD found in `.clavix/outputs/`. Use `/clavix:prd` or `/clavix:summarize` first."
-
-2. **Run the CLI command**:
-   ```bash
-   clavix plan
-   ```
-
-   Or specify a project:
-   ```bash
-   clavix plan --project project-name
-   ```
-
-   Or generate from saved session (auto-creates mini-prd.md):
-   ```bash
-   clavix plan --session SESSION_ID
-   ```
-
-3. **CLI will handle**:
-   - Project selection (if multiple)
-   - Reading PRD content
-   - Generating task breakdown
-   - Creating `tasks.md` file
-   - Formatting with proper task IDs
-
-#### **Option 2: Generate Tasks Directly** (If agent has full PRD context)
-
-If you have the full PRD content in memory and want to generate tasks directly:
-
-1. **Read the PRD** from `.clavix/outputs/[project-name]/`
-2. **Generate task breakdown** following Part B principles
-3. **Create `tasks.md`** with format specified in "Task Format Reference" below
-4. **Save to**: `.clavix/outputs/[project-name]/tasks.md`
-5. **Use exact format** (task IDs, checkboxes, structure)
-
-### Part B: Behavioral Guidance (Task Breakdown Strategy)
-
-3. **How to structure tasks** (optimized task breakdown):
-
-   **Task Granularity Principles:**
-   - **Clarity**: Each task = 1 clear action (not "Build authentication system", but "Create user registration endpoint")
-   - **Structure**: Tasks flow in implementation order (database schema → backend logic → frontend UI)
-   - **Actionability**: Tasks specify deliverable (not "Add tests", but "Write unit tests for user service with >80% coverage")
-
-   **Atomic Task Guidelines:**
-   - **Ideal size**: Completable in 15-60 minutes
-   - **Too large**: "Implement user authentication" → Break into registration, login, logout, password reset
-   - **Too small**: "Import React" → Combine with "Setup component structure"
-   - **Dependencies**: If Task B needs Task A, ensure A comes first
-
-   **Phase Organization:**
-   - Group related tasks into phases (Setup, Core Features, Testing, Polish)
-   - Each phase should be independently deployable when possible
-   - Critical path first (must-haves before nice-to-haves)
-
-4. **Review and customize generated tasks**:
-   - The command will generate `tasks.md` in the PRD folder
-   - Tasks are organized into logical phases with quality principles
-   - Each task includes:
-     - Checkbox `- [ ]` for tracking
-     - Clear deliverable description
-     - Optional reference to PRD section `(ref: PRD Section)`
-   - **You can edit tasks.md** before implementing:
-     - Add/remove tasks
-     - Adjust granularity
-     - Reorder for better flow
-     - Add notes or sub-tasks
-
-5. **Task Quality Labeling** (optional, for education):
-   When reviewing tasks, you can annotate improvements:
-   - **[Clarity]**: "Split vague 'Add UI' into 3 concrete tasks"
-   - **[Structure]**: "Reordered tasks: database schema before API endpoints"
-   - **[Actionability]**: "Added specific acceptance criteria (>80% test coverage)"
-
-6. **Next steps**:
-   - Review and edit `tasks.md` if needed
-   - Then run `/clavix:implement` to start implementation
-
-## Task Format
-
-The generated `tasks.md` will look like:
-
-```markdown
-# Implementation Tasks
-
-**Project**: [Project Name]
-**Generated**: [Timestamp]
-
----
-
-## Phase 1: Feature Name
-
-- [ ] Task 1 description (ref: PRD Section)
-  Task ID: phase-1-feature-name-1
-
-- [ ] Task 2 description
-  Task ID: phase-1-feature-name-2
-
-- [ ] Task 3 description
-  Task ID: phase-1-feature-name-3
-
-## Phase 2: Another Feature
-
-- [ ] Task 4 description
-  Task ID: phase-2-another-feature-1
-
-- [ ] Task 5 description
-  Task ID: phase-2-another-feature-2
-
----
-
-*Generated by Clavix /clavix:plan*
-```
-
-## Task Format Reference (For Agent-Direct Generation)
-
-**If you're generating tasks directly (Option 2), follow this exact format:**
-
-### File Structure
-```markdown
-# Implementation Tasks
-
-**Project**: {project-name}
-**Generated**: {ISO timestamp}
-
----
-
-## Phase {number}: {Phase Name}
-
-- [ ] {Task description} (ref: {PRD Section})
-  Task ID: {task-id}
-
-## Phase {number}: {Next Phase}
-
-- [ ] {Task description}
-  Task ID: {task-id}
-
----
-
-*Generated by Clavix /clavix:plan*
-```
-
-### Task ID Format
-
-**Pattern**: `phase-{phase-number}-{sanitized-phase-name}-{task-counter}`
-
-**Rules**:
-- Phase number: Sequential starting from 1
-- Sanitized phase name: Lowercase, spaces→hyphens, remove special chars
-- Task counter: Sequential within phase, starting from 1
-
-**Examples**:
-- Phase "Setup & Configuration" → Task 1 → `phase-1-setup-configuration-1`
-- Phase "User Authentication" → Task 3 → `phase-2-user-authentication-3`
-- Phase "API Integration" → Task 1 → `phase-3-api-integration-1`
-
-### Checkbox Format
-
-**Always use**: `- [ ]` for incomplete tasks (space between brackets)
-**Completed tasks**: `- [x]` (lowercase x, no spaces)
-
-### Task Description Format
-
-**Basic**: `- [ ] {Clear, actionable description}`
-**With reference**: `- [ ] {Description} (ref: {PRD Section Name})`
-
-**Example**:
-```markdown
-- [ ] Create user registration API endpoint (ref: User Management)
-  Task ID: phase-1-authentication-1
-```
-
-### Task ID Placement
-
-**Critical**: Task ID must be on the line immediately after the task description
-**Format**: `  Task ID: {id}` (2 spaces indent)
-
-### Phase Header Format
-
-**Pattern**: `## Phase {number}: {Phase Name}`
-**Must have**: Empty line before and after phase header
-
-### File Save Location
-
-**Path**: `.clavix/outputs/{project-name}/tasks.md`
-**Create directory if not exists**: Yes
-**Overwrite if exists**: Only with explicit user confirmation or `--overwrite` flag
-
-## Workflow Navigation
-
-**You are here:** Plan (Task Breakdown)
-
-**Common workflows:**
-- **PRD workflow**: `/clavix:prd` → `/clavix:plan` → `/clavix:implement` → `/clavix:archive`
-- **Conversation workflow**: `/clavix:summarize` → `/clavix:plan` → `/clavix:implement` → `/clavix:archive`
-- **Standalone**: [Existing PRD] → `/clavix:plan` → Review tasks.md → `/clavix:implement`
-
-**Related commands:**
-- `/clavix:prd` - Generate PRD (typical previous step)
-- `/clavix:summarize` - Extract mini-PRD from conversation (alternative previous step)
-- `/clavix:implement` - Execute generated tasks (next step)
-
-## Tips
-
-- Tasks are automatically optimized for clarity, structure, and actionability
-- Each task is concise and actionable
-- Tasks can reference specific PRD sections
-- Supports mini-PRD outputs from `/clavix:summarize` and session workflows via `--session` or `--active-session`
-- You can manually edit tasks.md before implementing
-- Use `--overwrite` flag to regenerate if needed
-
-## Troubleshooting
-
-### Issue: No PRD found in `.clavix/outputs/`
-**Cause**: User hasn't generated a PRD yet
-
-**Agent recovery**:
-1. Check if `.clavix/outputs/` directory exists:
-   ```bash
-   ls .clavix/outputs/
-   ```
-2. If directory doesn't exist or is empty:
-   - Error: "No PRD artifacts found in `.clavix/outputs/`"
-   - Suggest recovery options:
-     - "Generate PRD with `/clavix:prd` for comprehensive planning"
-     - "Extract mini-PRD from conversation with `/clavix:summarize`"
-     - "Or use `clavix plan --session <id>` if you have a saved session"
-3. Do NOT proceed with plan generation without PRD
-
-### Issue: Generated tasks are too granular (100+ tasks)
-**Cause**: Over-decomposition or large project scope
-
-**Agent recovery**:
-1. Review generated tasks in `tasks.md`
-2. Identify micro-tasks that can be combined
-3. Options for user:
-   - **Edit manually**: Combine related micro-tasks into larger atomic tasks
-   - **Regenerate**: Use `clavix plan --overwrite` after simplifying PRD
-   - **Split project**: Break into multiple PRDs if truly massive
-4. Guideline: Each task should be 15-60 minutes, not 5 minutes
-5. Combine setup/configuration tasks that belong together
-
-### Issue: Generated tasks are too high-level (only 3-4 tasks)
-**Cause**: PRD was too vague or task breakdown too coarse
-
-**Agent recovery**:
-1. Read the PRD to assess detail level
-2. If PRD is vague:
-   - Suggest: "Let's improve the PRD with `/clavix:deep` first"
-   - Then regenerate tasks with `clavix plan --overwrite`
-3. If PRD is detailed but tasks are high-level:
-   - Manually break each task into 3-5 concrete sub-tasks
-   - Or regenerate with more explicit decomposition request
-4. Each task should have clear, testable deliverable
-
-### Issue: Tasks don't follow logical dependency order
-**Cause**: Generator didn't detect dependencies correctly OR agent-generated tasks weren't ordered
-
-**Agent recovery**:
-1. Review task order in `tasks.md`
-2. Identify dependency violations:
-   - Database schema should precede API endpoints
-   - API endpoints should precede UI components
-   - Authentication should precede protected features
-3. Manually reorder tasks in `tasks.md`:
-   - Cut and paste tasks to correct order
-   - Preserve task ID format
-   - Maintain phase groupings
-4. Follow structure principle: ensure sequential coherence
-
-### Issue: Tasks conflict with PRD or duplicate work
-**Cause**: Misinterpretation of PRD or redundant task generation
-
-**Agent recovery**:
-1. Read PRD and tasks.md side-by-side
-2. Identify conflicts or duplicates
-3. Options:
-   - **Remove duplicates**: Delete redundant tasks from tasks.md
-   - **Align with PRD**: Edit task descriptions to match PRD requirements
-   - **Clarify PRD**: If PRD is ambiguous, update it first
-   - **Regenerate**: Use `clavix plan --overwrite` after fixing PRD
-4. Ensure each PRD feature maps to tasks
-
-### Issue: `tasks.md` already exists, unsure if should regenerate
-**Cause**: Previous plan exists for this PRD
-
-**Agent recovery**:
-1. Read existing `tasks.md`
-2. Count completed tasks (check for `[x]` checkboxes)
-3. Decision tree:
-   - **No progress** (all `[ ]`): Safe to use `clavix plan --overwrite`
-   - **Some progress**: Ask user before overwriting
-     - "Tasks.md has {X} completed tasks. Regenerating will lose this progress. Options:
-       1. Keep existing tasks.md and edit manually
-       2. Overwrite and start fresh (progress lost)
-       3. Cancel plan generation"
-   - **Mostly complete**: Recommend NOT overwriting
-4. If user confirms overwrite: Run `clavix plan --project {name} --overwrite`
-
-### Issue: CLI command fails or no output
-**Cause**: Missing dependencies, corrupted PRD file, or CLI error
-
-**Agent recovery**:
-1. Check CLI error output
-2. Common fixes:
-   - Verify PRD file exists and is readable
-   - Check `.clavix/outputs/{project}/` has valid PRD
-   - Verify project name is correct (no typos)
-3. Try with explicit project: `clavix plan --project {exact-name}`
-4. If persistent: Inform user to check Clavix installation