feat(v5.2.2): Add intelligent skip logic to /memory:skill-memory with parameter naming correction

## Smart Documentation Generation
- Automatically detects existing documentation and skips Phase 2/3 when docs exist
- Jump directly to Phase 4 (SKILL.md generation) for fast SKILL index updates
- Phase 4 always executes to ensure SKILL.md stays synchronized
- Explicit --regenerate flag for forced full documentation refresh

## Parameter Naming Correction
- Reverted --update back to --regenerate for accurate semantic meaning
- "regenerate" = delete and recreate (destructive operation)
- "update" was misleading (implied incremental update, not implemented)

## Execution Paths
- Full Path: All 4 phases (no docs OR --regenerate specified)
- Skip Path: Phase 1 → Phase 4 (docs exist AND no --regenerate)
- Added comprehensive TodoWrite patterns and flow diagrams for both paths

## Phase 1 Enhancement
- Step 4: Determine Execution Path - decision logic with SKIP_DOCS_GENERATION flag
- Checks existing documentation count
- Evaluates --regenerate flag presence
- Displays appropriate skip or regeneration messages

## Benefits
- 5-10x faster SKILL updates when documentation already exists
- Always fresh SKILL.md index reflecting current documentation structure
- Explicit control via --regenerate flag for full refresh

## Modified Files
- .claude/commands/memory/skill-memory.md (553 lines, +59 lines for skip logic)
- CHANGELOG.md (added v5.2.2 release notes)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.claude/commands/memory/docs.md

@@ -11,9 +11,9 @@ Lightweight planner that analyzes project structure, decomposes documentation wo
 
 **Execution Strategy**:
 - **Dynamic Task Grouping**: Level 1 tasks grouped by top-level directories with document count limit
-  - **Primary constraint**: Each task generates ≤7 documents (API.md + README.md count)
+  - **Primary constraint**: Each task generates ≤10 documents (API.md + README.md count)
   - **Optimization goal**: Prefer grouping 2 top-level directories per task for context sharing
-  - **Conflict resolution**: If 2 dirs exceed 7 docs, reduce to 1 dir/task; if 1 dir exceeds 7 docs, split by subdirectories
+  - **Conflict resolution**: If 2 dirs exceed 10 docs, reduce to 1 dir/task; if 1 dir exceeds 10 docs, split by subdirectories
   - **Context benefit**: Same-task directories analyzed together via single Gemini call
 - **Parallel Execution**: Multiple Level 1 tasks execute concurrently for faster completion
 - **Pre-computed Analysis**: Phase 2 performs unified analysis once, stored in `.process/` for reuse
@@ -140,42 +140,42 @@ bash(cat .workflow/WFS-docs-{timestamp}/.process/phase2-analysis.json | jq '.exi
 **Task Hierarchy** (Dynamic based on document count):
 
 ```
-Small Projects (total ≤7 docs):
+Small Projects (total ≤10 docs):
   Level 1: IMPL-001 (all directories in single task, shared context)
   Level 2: IMPL-002 (README, full mode only)
   Level 3: IMPL-003 (ARCHITECTURE+EXAMPLES), IMPL-004 (HTTP API, optional)
 
-Medium Projects (Example: 7 top-level dirs, 12 total docs):
+Medium Projects (Example: 7 top-level dirs, 18 total docs):
   Step 1: Count docs per top-level dir
-    ├─ dir1: 2 docs, dir2: 3 docs → Group 1 (5 docs)
-    ├─ dir3: 4 docs, dir4: 2 docs → Group 2 (6 docs)
-    ├─ dir5: 1 doc → Group 3 (1 doc, can add more)
+    ├─ dir1: 3 docs, dir2: 4 docs → Group 1 (7 docs)
+    ├─ dir3: 5 docs, dir4: 3 docs → Group 2 (8 docs)
+    ├─ dir5: 2 docs → Group 3 (2 docs, can add more)
 
-  Step 2: Create tasks with ≤7 docs constraint
+  Step 2: Create tasks with ≤10 docs constraint
   Level 1: IMPL-001 to IMPL-003 (parallel groups)
-    ├─ IMPL-001: Group 1 (dir1 + dir2, 5 docs, shared context)
-    ├─ IMPL-002: Group 2 (dir3 + dir4, 6 docs, shared context)
-    └─ IMPL-003: Group 3 (remaining dirs, ≤7 docs)
+    ├─ IMPL-001: Group 1 (dir1 + dir2, 7 docs, shared context)
+    ├─ IMPL-002: Group 2 (dir3 + dir4, 8 docs, shared context)
+    └─ IMPL-003: Group 3 (remaining dirs, ≤10 docs)
   Level 2: IMPL-004 (README, depends on Level 1, full mode only)
   Level 3: IMPL-005 (ARCHITECTURE+EXAMPLES), IMPL-006 (HTTP API, optional)
 
-Large Projects (single dir >7 docs):
+Large Projects (single dir >10 docs):
   Step 1: Detect oversized directory
-    └─ src/modules/: 12 subdirs → 24 docs (exceeds limit)
+    └─ src/modules/: 15 subdirs → 30 docs (exceeds limit)
 
   Step 2: Split by subdirectories
-  Level 1: IMPL-001 to IMPL-004 (split oversized dir)
-    ├─ IMPL-001: src/modules/ subdirs 1-3 (6 docs)
-    ├─ IMPL-002: src/modules/ subdirs 4-6 (6 docs)
-    └─ IMPL-003: src/modules/ subdirs 7-12 (12 docs) → further split
+  Level 1: IMPL-001 to IMPL-003 (split oversized dir)
+    ├─ IMPL-001: src/modules/ subdirs 1-5 (10 docs)
+    ├─ IMPL-002: src/modules/ subdirs 6-10 (10 docs)
+    └─ IMPL-003: src/modules/ subdirs 11-15 (10 docs)
 ```
 
 **Grouping Algorithm**:
 1. Count total docs for each top-level directory
 2. Try grouping 2 directories (optimization for context sharing)
-3. If group exceeds 7 docs, split to 1 dir/task
-4. If single dir exceeds 7 docs, split by subdirectories
-5. Create parallel Level 1 tasks with ≤7 docs each
+3. If group exceeds 10 docs, split to 1 dir/task
+4. If single dir exceeds 10 docs, split by subdirectories
+5. Create parallel Level 1 tasks with ≤10 docs each
 
 **Benefits**: Parallel execution, failure isolation, progress visibility, context sharing, document count control.
 
@@ -196,11 +196,11 @@ bash(grep -r "router\.|@Get\|@Post" src/ 2>/dev/null && echo "API_FOUND" || echo
 1. Count documents for each top-level directory (from folder_analysis):
    - Code folders: 2 docs each (API.md + README.md)
    - Navigation folders: 1 doc each (README.md only)
-2. Apply grouping algorithm with ≤7 docs constraint:
+2. Apply grouping algorithm with ≤10 docs constraint:
    - Try grouping 2 directories, calculate total docs
-   - If total ≤7 docs: create group
-   - If total >7 docs: split to 1 dir/group or subdivide
-   - If single dir >7 docs: split by subdirectories
+   - If total ≤10 docs: create group
+   - If total >10 docs: split to 1 dir/group or subdivide
+   - If single dir >10 docs: split by subdirectories
 3. Use **Edit tool** to update `phase2-analysis.json` adding groups field:
    ```json
    "groups": {

.claude/commands/memory/load-skill-memory.md

@@ -0,0 +1,132 @@
+---
+name: load-skill-memory
+description: Manually activate specified SKILL package and load documentation based on task intent
+argument-hint: "<skill_name> \"task intent description\""
+allowed-tools: Bash(*), Read(*), Skill(*)
+---
+
+# Memory Load SKILL Command (/memory:load-skill-memory)
+
+## 1. Overview
+
+The `memory:load-skill-memory` command **manually activates a specified SKILL package** and intelligently loads documentation based on user's task intent. The system automatically determines which documentation files to read based on the intent description.
+
+**Core Philosophy**:
+- **Manual Activation**: User explicitly specifies which SKILL to activate
+- **Intent-Driven Loading**: System analyzes task intent to determine documentation scope
+- **Intelligent Selection**: Automatically chooses appropriate documentation level and modules
+- **Direct Context Loading**: Loads selected documentation into conversation memory
+
+**When to Use**:
+- Manually activate a known SKILL package for a specific task
+- Load SKILL context when system hasn't auto-triggered it
+- Force reload SKILL documentation with specific intent focus
+
+**Note**: Normal SKILL activation happens automatically via description triggers. Use this command only when manual activation is needed.
+
+## 2. Parameters
+
+- `<skill_name>` (Required): Name of SKILL package to activate
+  - Example: `hydro_generator_module`, `Claude_dms3`
+  - Must match directory name under `.claude/skills/`
+
+- `"task intent description"` (Required): Description of what you want to do
+  - **Analysis tasks**: "分析builder pattern实现", "理解参数系统架构"
+  - **Modification tasks**: "修改workflow逻辑", "增强thermal template功能"
+  - **Learning tasks**: "学习接口设计模式", "了解测试框架使用"
+
+## 3. Execution Flow
+
+### Step 1: Activate SKILL and Analyze Intent
+
+**Activate SKILL Package**:
+```javascript
+Skill(command: "${skill_name}")
+```
+
+**What Happens After Activation**:
+1. If SKILL exists in memory: System reads `.claude/skills/${skill_name}/SKILL.md`
+2. If SKILL not found in memory: Error - SKILL package doesn't exist
+3. SKILL description triggers are loaded into memory
+4. Progressive loading mechanism becomes available
+5. Documentation structure is now accessible
+
+**Intent Analysis**:
+Based on task intent description, system determines:
+- **Action type**: analyzing, modifying, learning
+- **Scope**: specific module, architecture overview, complete system
+- **Depth**: quick reference, detailed API, full documentation
+
+### Step 2: Intelligent Documentation Loading
+
+**Loading Strategy**:
+
+The system automatically selects documentation based on intent keywords:
+
+1. **Quick Understanding** ("了解", "快速理解", "什么是"):
+   - Load: Level 0 (README.md only, ~2K tokens)
+   - Use case: Quick overview of capabilities
+
+2. **Specific Module Analysis** ("分析XXX模块", "理解XXX实现"):
+   - Load: Module-specific README.md + API.md (~5K tokens)
+   - Use case: Deep dive into specific component
+
+3. **Architecture Review** ("架构", "设计模式", "整体结构"):
+   - Load: README.md + ARCHITECTURE.md (~10K tokens)
+   - Use case: System design understanding
+
+4. **Implementation/Modification** ("修改", "增强", "实现"):
+   - Load: Relevant module docs + EXAMPLES.md (~15K tokens)
+   - Use case: Code modification with examples
+
+5. **Comprehensive Learning** ("学习", "完整了解", "深入理解"):
+   - Load: Level 3 (All documentation, ~40K tokens)
+   - Use case: Complete system mastery
+
+**Documentation Loaded into Memory**:
+After loading, the selected documentation content is available in conversation memory for subsequent operations.
+
+## 4. Usage Example
+
+**User Command**:
+```bash
+/memory:load-skill-memory my_project "修改认证模块增加OAuth支持"
+```
+
+**Execution**:
+```javascript
+// Step 1: Activate SKILL
+Skill(command: "my_project")
+
+// Intent Analysis
+Keywords: ["修改", "认证模块", "增加", "OAuth"]
+Action: modifying (implementation)
+Scope: auth module + examples
+
+// Step 2: Load documentation based on intent
+Read(.workflow/docs/my_project/auth/README.md)
+Read(.workflow/docs/my_project/auth/API.md)
+Read(.workflow/docs/my_project/EXAMPLES.md)
+```
+
+## 5. Intent Keyword Mapping
+
+**Quick Reference**:
+- **Triggers**: "了解", "快速", "什么是", "简介"
+- **Loads**: README.md only (~2K)
+
+**Module-Specific**:
+- **Triggers**: "XXX模块", "XXX组件", "分析XXX"
+- **Loads**: Module README + API (~5K)
+
+**Architecture**:
+- **Triggers**: "架构", "设计", "整体结构", "系统设计"
+- **Loads**: README + ARCHITECTURE (~10K)
+
+**Implementation**:
+- **Triggers**: "修改", "增强", "实现", "开发", "集成"
+- **Loads**: Relevant module + EXAMPLES (~15K)
+
+**Comprehensive**:
+- **Triggers**: "完整", "深入", "全面", "学习整个"
+- **Loads**: All documentation (~40K)

.claude/commands/memory/skill-memory.md

@@ -11,28 +11,36 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Bash(*), Read(*), Write(*)
 
 **This command is a pure orchestrator**: Execute documentation generation workflow, then generate SKILL.md index. Does NOT create task JSON files.
 
-**Execution Model - 4-Phase Workflow**:
+**Execution Model - Auto-Continue Workflow**:
+
+This workflow runs **fully autonomously** once triggered. Each phase completes and automatically triggers the next phase.
 
 1. **User triggers**: `/memory:skill-memory [path] [options]`
-2. **Phase 1**: Parse arguments and prepare → Auto-continues
-3. **Phase 2**: Call `/memory:docs` to plan documentation → Auto-continues
-4. **Phase 3**: Call `/workflow:execute` to generate docs → Auto-continues
-5. **Phase 4**: Generate SKILL.md index → Reports completion
+2. **Phase 1 executes** → Parse arguments and prepare → Auto-continues
+3. **Phase 2 executes** → Call `/memory:docs` to plan documentation → Auto-continues
+4. **Phase 3 executes** → Call `/workflow:execute` to generate docs → Auto-continues
+5. **Phase 4 executes** → Generate SKILL.md index → Reports completion
 
 **Auto-Continue Mechanism**:
-- TodoList tracks current phase status
-- After each phase completion, automatically executes next phase
+- TodoList tracks current phase status (in_progress/completed)
+- After each phase completion, check TodoList and automatically execute next pending phase
 - All phases run autonomously without user interaction
-- Progress updates shown at each phase
+- Progress updates shown at each phase for visibility
+- Each phase MUST update TodoWrite before triggering next phase
 
 ## Core Rules
 
 1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 execution
 2. **No Task JSON**: This command does not create task JSON files - delegates to /memory:docs
-3. **Parse Every Output**: Extract required data from each command output
-4. **Auto-Continue via TodoList**: Check TodoList status to execute next phase automatically
-5. **Track Progress**: Update TodoWrite after every phase completion
+3. **Parse Every Output**: Extract required data from each command output (session_id, task_count, file paths)
+4. **Auto-Continue via TodoList**: After completing each phase:
+   - Update TodoWrite to mark current phase completed
+   - Mark next phase as in_progress
+   - Immediately execute next phase (no waiting for user input)
+   - Check TodoList to identify next pending phase automatically
+5. **Track Progress**: Update TodoWrite after EVERY phase completion before starting next phase
 6. **Direct Generation**: Phase 4 directly generates SKILL.md using Write tool
+7. **No Manual Steps**: User should never be prompted for decisions between phases - fully autonomous execution
 
 ## 4-Phase Execution
 
@@ -79,13 +87,24 @@ bash(find .workflow/docs/my_project -name "*.md" 2>/dev/null | wc -l || echo 0)
 - `docs_exists`: `exists` or `not_exists`
 - `existing_docs`: `5` (or `0` if no docs)
 
-**Step 4: Handle --regenerate Flag (If Specified)**
-```bash
-# If user specified --regenerate, delete existing docs directory
-bash(rm -rf .workflow/docs/my_project 2>/dev/null || true)
+**Step 4: Determine Execution Path**
 
-# Verify deletion
-bash(test -d .workflow/docs/my_project && echo "still_exists" || echo "deleted")
+**Decision Logic**:
+```javascript
+if (existing_docs > 0 && !regenerate_flag) {
+  // Documentation exists and no regenerate flag
+  SKIP_DOCS_GENERATION = true
+  message = "Documentation already exists, skipping Phase 2 and Phase 3. Use --regenerate to force regeneration."
+} else if (regenerate_flag) {
+  // Force regeneration: delete existing docs
+  bash(rm -rf .workflow/docs/my_project 2>/dev/null || true)
+  SKIP_DOCS_GENERATION = false
+  message = "Regenerating documentation from scratch."
+} else {
+  // No existing docs
+  SKIP_DOCS_GENERATION = false
+  message = "No existing documentation found, generating new documentation."
+}
 ```
 
 **Summary**:
@@ -96,16 +115,30 @@ bash(test -d .workflow/docs/my_project && echo "still_exists" || echo "deleted")
 - `MODE`: `full` (default) or user-specified
 - `CLI_EXECUTE`: `false` (default) or `true` if --cli-execute flag
 - `REGENERATE`: `false` (default) or `true` if --regenerate flag
-- `EXISTING_DOCS`: `0` (after regenerate) or actual count
+- `EXISTING_DOCS`: Count of existing documentation files
+- `SKIP_DOCS_GENERATION`: `true` if skipping Phase 2/3, `false` otherwise
 
-**TodoWrite**: Mark phase 1 completed, phase 2 in_progress
+**Completion Criteria**:
+- All parameters extracted and validated
+- Project name and paths confirmed
+- Existing docs count retrieved
+- Skip decision determined (SKIP_DOCS_GENERATION)
+- Default values set for unspecified parameters
 
-**After Phase 1**: Display preparation results, auto-continue to Phase 2
+**TodoWrite**:
+- If `SKIP_DOCS_GENERATION = true`: Mark phase 1 completed, phase 4 in_progress (skip phase 2 and 3)
+- If `SKIP_DOCS_GENERATION = false`: Mark phase 1 completed, phase 2 in_progress
+
+**After Phase 1**:
+- If skipping: Display skip message → **Jump to Phase 4** (SKILL.md generation)
+- If not skipping: Display preparation results → **Continue to Phase 2** (documentation planning)
 
 ---
 
 ### Phase 2: Call /memory:docs
 
+**Note**: This phase is **skipped if SKIP_DOCS_GENERATION = true** (documentation already exists without --regenerate flag)
+
 **Goal**: Trigger documentation generation workflow
 
 **Command**:
@@ -131,18 +164,23 @@ SlashCommand(command="/memory:docs [targetPath] --tool [tool] --mode [mode] [--c
 - Extract session ID pattern: `WFS-docs-[timestamp]` (store as `docsSessionId`)
 - Extract task count (store as `taskCount`)
 
-**Validation**:
-- Session ID extracted successfully
+**Completion Criteria**:
+- `/memory:docs` command executed successfully
+- Session ID extracted: `WFS-docs-[timestamp]`
+- Task count retrieved from output
 - Task files created in `.workflow/[docsSessionId]/.task/`
+- workflow-session.json exists in session directory
 
 **TodoWrite**: Mark phase 2 completed, phase 3 in_progress
 
-**After Phase 2**: Display docs planning results, auto-continue to Phase 3
+**After Phase 2**: Display docs planning results (session ID, task count) → **Automatically continue to Phase 3** (no user input required)
 
 ---
 
 ### Phase 3: Execute Documentation Generation
 
+**Note**: This phase is **skipped if SKIP_DOCS_GENERATION = true** (documentation already exists without --regenerate flag)
+
 **Goal**: Execute documentation generation tasks
 
 **Command**:
@@ -152,13 +190,16 @@ SlashCommand(command="/workflow:execute")
 
 **Note**: `/workflow:execute` automatically discovers active session from Phase 2
 
-**Validation**:
+**Completion Criteria**:
+- `/workflow:execute` command executed successfully
 - Documentation files generated in `.workflow/docs/[projectName]/`
-- All tasks completed successfully
+- All tasks marked as completed in session
+- At minimum, module documentation files exist (API.md and/or README.md)
+- For full mode: Project README, ARCHITECTURE, EXAMPLES files generated
 
 **TodoWrite**: Mark phase 3 completed, phase 4 in_progress
 
-**After Phase 3**: Display execution results, auto-continue to Phase 4
+**After Phase 3**: Display execution results (file count, module count) → **Automatically continue to Phase 4** (no user input required)
 
 ---
 
@@ -177,8 +218,18 @@ bash(find .workflow/docs/{project_name} -name "*.md" | sed 's|.workflow/docs/{pr
 
 Extract from README + structure: Function (capabilities), Modules (names), Keywords (API/CLI/auth/etc.)
 
-**Format**: `{Function}. Use when {trigger conditions}.`
-**Example**: "Workflow management with CLI tools. Use when working with workflow orchestration or docs generation."
+**Format**: `{Project} {core capabilities} (located at {project_path}). Load this SKILL when analyzing, modifying, or learning about {domain_description} or files under this path, especially when no relevant context exists in memory.`
+
+**Path Reference**: Use `TARGET_PATH` from Phase 1 for precise location identification.
+
+**Domain Description**: Extract human-readable domain/feature area from README (e.g., "workflow management", "thermal modeling"), NOT the technical project_name.
+
+**Trigger Optimization**:
+- Include project path to improve triggering when users mention specific directories or file locations
+- Emphasize "especially when no relevant context exists in memory" to prioritize SKILL as primary context source
+- Cover three key actions: analyzing (分析), modifying (修改), learning (了解)
+
+**Example**: "Workflow orchestration system with CLI tools and documentation generation (located at /d/Claude_dms3). Load this SKILL when analyzing, modifying, or learning about workflow management or files under this path, especially when no relevant context exists in memory."
 
 **Step 4: Write SKILL.md** (Use Write tool)
 ```bash
@@ -194,21 +245,30 @@ version: 1.0.0
 ---
 # {Project Name} SKILL Package
 
-## Documentation: `../../.workflow/docs/{project_name}/`
+## Documentation: `../../../.workflow/docs/{project_name}/`
 
 ## Progressive Loading
 ### Level 0: Quick Start (~2K)
-- [README](../../.workflow/docs/{project_name}/README.md)
+- [README](../../../.workflow/docs/{project_name}/README.md)
 ### Level 1: Core Modules (~8K)
 {Module READMEs}
 ### Level 2: Complete (~25K)
-All modules + [Architecture](../../.workflow/docs/{project_name}/ARCHITECTURE.md)
+All modules + [Architecture](../../../.workflow/docs/{project_name}/ARCHITECTURE.md)
 ### Level 3: Deep Dive (~40K)
-Everything + [Examples](../../.workflow/docs/{project_name}/EXAMPLES.md)
+Everything + [Examples](../../../.workflow/docs/{project_name}/EXAMPLES.md)
 ```
 
+**Completion Criteria**:
+- SKILL.md file created at `.claude/skills/{project_name}/SKILL.md`
+- Intelligent description generated from documentation
+- Progressive loading levels (0-3) properly structured
+- Module index includes all documented modules
+- All file references use relative paths
+
 **TodoWrite**: Mark phase 4 completed
 
+**After Phase 4**: Workflow complete → **Report final summary to user**
+
 **Return to User**:
 ```
 ✅ SKILL Package Generation Complete
@@ -233,40 +293,172 @@ Usage:
 
 ## TodoWrite Pattern
 
+**Auto-Continue Logic**: After updating TodoWrite at end of each phase, immediately check for next pending task and execute it.
+
+**Two Execution Paths**:
+1. **Full Path**: All 4 phases (no existing docs or --regenerate specified)
+2. **Skip Path**: Phase 1 → Phase 4 (existing docs found, no --regenerate)
+
+### Full Path (SKIP_DOCS_GENERATION = false)
+
 ```javascript
 // Initialize (before Phase 1)
+// FIRST ACTION: Create TodoList with all 4 phases
 TodoWrite({todos: [
   {"content": "Parse arguments and prepare", "status": "in_progress", "activeForm": "Parsing arguments"},
   {"content": "Call /memory:docs to plan documentation", "status": "pending", "activeForm": "Calling /memory:docs"},
   {"content": "Execute documentation generation", "status": "pending", "activeForm": "Executing documentation"},
   {"content": "Generate SKILL.md index", "status": "pending", "activeForm": "Generating SKILL.md"}
 ]})
+// SECOND ACTION: Execute Phase 1 immediately
 
-// After Phase 1
+// After Phase 1 completes (SKIP_DOCS_GENERATION = false)
+// Update TodoWrite: Mark Phase 1 completed, Phase 2 in_progress
 TodoWrite({todos: [
   {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
   {"content": "Call /memory:docs to plan documentation", "status": "in_progress", "activeForm": "Calling /memory:docs"},
   {"content": "Execute documentation generation", "status": "pending", "activeForm": "Executing documentation"},
   {"content": "Generate SKILL.md index", "status": "pending", "activeForm": "Generating SKILL.md"}
 ]})
+// NEXT ACTION: Auto-continue to Phase 2 (execute /memory:docs command)
 
-// After Phase 2
+// After Phase 2 completes
+// Update TodoWrite: Mark Phase 2 completed, Phase 3 in_progress
 TodoWrite({todos: [
   {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
   {"content": "Call /memory:docs to plan documentation", "status": "completed", "activeForm": "Calling /memory:docs"},
   {"content": "Execute documentation generation", "status": "in_progress", "activeForm": "Executing documentation"},
   {"content": "Generate SKILL.md index", "status": "pending", "activeForm": "Generating SKILL.md"}
 ]})
+// NEXT ACTION: Auto-continue to Phase 3 (execute /workflow:execute command)
 
-// After Phase 3
+// After Phase 3 completes
+// Update TodoWrite: Mark Phase 3 completed, Phase 4 in_progress
 TodoWrite({todos: [
   {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
   {"content": "Call /memory:docs to plan documentation", "status": "completed", "activeForm": "Calling /memory:docs"},
   {"content": "Execute documentation generation", "status": "completed", "activeForm": "Executing documentation"},
   {"content": "Generate SKILL.md index", "status": "in_progress", "activeForm": "Generating SKILL.md"}
 ]})
+// NEXT ACTION: Auto-continue to Phase 4 (generate SKILL.md)
+
+// After Phase 4 completes
+// Update TodoWrite: Mark Phase 4 completed
+TodoWrite({todos: [
+  {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
+  {"content": "Call /memory:docs to plan documentation", "status": "completed", "activeForm": "Calling /memory:docs"},
+  {"content": "Execute documentation generation", "status": "completed", "activeForm": "Executing documentation"},
+  {"content": "Generate SKILL.md index", "status": "completed", "activeForm": "Generating SKILL.md"}
+]})
+// FINAL ACTION: Report completion summary to user
 ```
 
+### Skip Path (SKIP_DOCS_GENERATION = true)
+
+**Note**: Phase 4 (SKILL.md generation) is **NEVER skipped** - it always runs to generate or update the SKILL index.
+
+```javascript
+// Initialize (before Phase 1)
+// FIRST ACTION: Create TodoList with all 4 phases (same as Full Path)
+TodoWrite({todos: [
+  {"content": "Parse arguments and prepare", "status": "in_progress", "activeForm": "Parsing arguments"},
+  {"content": "Call /memory:docs to plan documentation", "status": "pending", "activeForm": "Calling /memory:docs"},
+  {"content": "Execute documentation generation", "status": "pending", "activeForm": "Executing documentation"},
+  {"content": "Generate SKILL.md index", "status": "pending", "activeForm": "Generating SKILL.md"}
+]})
+// SECOND ACTION: Execute Phase 1 immediately
+
+// After Phase 1 completes (SKIP_DOCS_GENERATION = true)
+// Update TodoWrite: Mark Phase 1 completed, Phase 2&3 skipped, Phase 4 in_progress
+TodoWrite({todos: [
+  {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
+  {"content": "Call /memory:docs to plan documentation", "status": "completed", "activeForm": "Calling /memory:docs"},
+  {"content": "Execute documentation generation", "status": "completed", "activeForm": "Executing documentation"},
+  {"content": "Generate SKILL.md index", "status": "in_progress", "activeForm": "Generating SKILL.md"}
+]})
+// Display skip message: "Documentation already exists, skipping Phase 2 and Phase 3. Use --regenerate to force regeneration."
+// NEXT ACTION: Jump directly to Phase 4 (generate SKILL.md)
+
+// After Phase 4 completes
+// Update TodoWrite: Mark Phase 4 completed
+TodoWrite({todos: [
+  {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
+  {"content": "Call /memory:docs to plan documentation", "status": "completed", "activeForm": "Calling /memory:docs"},
+  {"content": "Execute documentation generation", "status": "completed", "activeForm": "Executing documentation"},
+  {"content": "Generate SKILL.md index", "status": "completed", "activeForm": "Generating SKILL.md"}
+]})
+// FINAL ACTION: Report completion summary to user
+```
+
+## Auto-Continue Execution Flow
+
+**Critical Implementation Rules**:
+
+1. **No User Prompts Between Phases**: Never ask user questions or wait for input between phases
+2. **Immediate Phase Transition**: After TodoWrite update, immediately execute next phase command
+3. **Status-Driven Execution**: Check TodoList status after each phase:
+   - If next task is "pending" → Mark it "in_progress" and execute
+   - If all tasks are "completed" → Report final summary
+4. **Phase Completion Pattern**:
+   ```
+   Phase N completes → Update TodoWrite (N=completed, N+1=in_progress) → Execute Phase N+1
+   ```
+
+**Execution Sequence**:
+
+**Full Path** (no existing docs OR --regenerate specified):
+```
+User triggers command
+  ↓
+[TodoWrite] Initialize 4 phases (Phase 1 = in_progress)
+  ↓
+[Execute] Phase 1: Parse arguments
+  ↓
+[TodoWrite] Phase 1 = completed, Phase 2 = in_progress
+  ↓
+[Execute] Phase 2: Call /memory:docs
+  ↓
+[TodoWrite] Phase 2 = completed, Phase 3 = in_progress
+  ↓
+[Execute] Phase 3: Call /workflow:execute
+  ↓
+[TodoWrite] Phase 3 = completed, Phase 4 = in_progress
+  ↓
+[Execute] Phase 4: Generate SKILL.md
+  ↓
+[TodoWrite] Phase 4 = completed
+  ↓
+[Report] Display completion summary
+```
+
+**Skip Path** (existing docs found AND no --regenerate flag):
+```
+User triggers command
+  ↓
+[TodoWrite] Initialize 4 phases (Phase 1 = in_progress)
+  ↓
+[Execute] Phase 1: Parse arguments, detect existing docs
+  ↓
+[TodoWrite] Phase 1 = completed, Phase 2&3 = completed (skipped), Phase 4 = in_progress
+  ↓
+[Display] Skip message: "Documentation already exists, skipping Phase 2 and Phase 3"
+  ↓
+[Execute] Phase 4: Generate SKILL.md (always runs)
+  ↓
+[TodoWrite] Phase 4 = completed
+  ↓
+[Report] Display completion summary
+```
+
+**Note**: Phase 4 (SKILL.md generation) is **NEVER skipped** - it always executes to generate or update the index file.
+
+**Error Handling**:
+- If any phase fails, mark it as "in_progress" (not completed)
+- Report error details to user
+- Do NOT auto-continue to next phase on failure
+
+---
+
 ## Parameters
 
 ```bash
@@ -309,8 +501,8 @@ TodoWrite({todos: [
 ```
 
 **Workflow**:
-1. Phase 1: Parses target path, detects regenerate flag
-2. Phase 2: Calls `/memory:docs /d/my_app --tool qwen --mode full` (regenerate handled in Phase 1)
+1. Phase 1: Parses target path, detects regenerate flag, deletes existing docs
+2. Phase 2: Calls `/memory:docs /d/my_app --tool qwen --mode full`
 3. Phase 3: Executes documentation regeneration
 4. Phase 4: Generates updated SKILL.md