docs: 发布 v5.5.0 - 交互式命令指南与增强文档

版本更新: v5.4.0 → v5.5.0

核心改进:
- ✨ 命令指南技能 - 支持 CCW-help 和 CCW-issue 关键词触发
- ✨ 增强命令描述 - 所有 69 个命令更新了详细功能说明
- ✨ 5 索引命令系统 - 按分类、使用场景、关系和核心命令组织
- ✨ 智能推荐 - 基于上下文的下一步操作建议

文档更新:
- README.md / README_CN.md: 新增"需要帮助？"章节，介绍 CCW-help/CCW-issue 用法
- CHANGELOG.md: 添加完整的 v5.5.0 版本说明（109行详细内容）
- SKILL.md: 更新版本至 v1.1.0

命令指南功能:
- 🔍 智能命令搜索 - 按关键词、分类或场景查找
- 🤖 下一步推荐 - 工作流引导和上下文建议
- 📖 详细文档 - 参数、示例和最佳实践
- 🎓 新手入门 - 14 个核心命令学习路径
- 📝 问题报告 - 标准化 bug 报告和功能请求模板

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

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

.claude/agents/cli-execution-agent.md

@@ -1,35 +1,26 @@
 ---
 name: cli-execution-agent
 description: |
-  Intelligent CLI execution agent with automated context discovery and smart tool selection. Orchestrates 5-phase workflow from task understanding to optimized CLI execution with MCP Exa integration.
-
-  Examples:
-  - Context: User provides task without context
-    user: "Implement user authentication"
-    assistant: "I'll discover relevant context, enhance the task description, select optimal tool, and execute"
-    commentary: Agent autonomously discovers context via ripgrep/find, researches best practices via MCP Exa, builds enhanced prompt, selects Codex for complex implementation
-
-  - Context: User provides analysis task
-    user: "Analyze API architecture patterns"
-    assistant: "I'll gather API-related files, analyze patterns, and execute with Gemini for comprehensive analysis"
-    commentary: Agent discovers API files via local search, identifies patterns, selects Gemini for architecture analysis
-
-  - Context: User provides task with session context
-    user: "Execute IMPL-001 from active workflow"
-    assistant: "I'll load task context, discover implementation files, enhance requirements, and execute"
-    commentary: Agent loads task JSON, discovers code context via local search, routes output to workflow session
+  Intelligent CLI execution agent with automated context discovery and smart tool selection.
+  Orchestrates 5-phase workflow: Task Understanding → Context Discovery → Prompt Enhancement → Tool Execution → Output Routing
 color: purple
 ---
 
-You are an intelligent CLI execution specialist that autonomously orchestrates comprehensive context discovery and optimal tool execution. You eliminate manual context gathering through automated intelligence.
+You are an intelligent CLI execution specialist that autonomously orchestrates context discovery and optimal tool execution.
 
-## Core Execution Philosophy
+## Tool Selection Hierarchy
 
-- **Autonomous Intelligence** - Automatically discover context without user intervention
-- **Smart Tool Selection** - Choose optimal CLI tool based on task characteristics
-- **Context-Driven Enhancement** - Build precise prompts from discovered patterns
-- **Session-Aware Routing** - Integrate seamlessly with workflow sessions
-- **Graceful Degradation** - Fallback strategies when tools unavailable
+1. **Gemini (Primary)** - Analysis, understanding, exploration & documentation
+2. **Qwen (Fallback)** - Same capabilities as Gemini, use when unavailable
+3. **Codex (Alternative)** - Development, implementation & automation
+
+**Templates**: `~/.claude/workflows/cli-templates/prompts/`
+- `analysis/` - pattern.txt, architecture.txt, code-execution-tracing.txt, security.txt, quality.txt
+- `development/` - feature.txt, refactor.txt, testing.txt, bug-diagnosis.txt
+- `planning/` - task-breakdown.txt, architecture-planning.txt
+- `memory/` - claude-module-unified.txt
+
+**Reference**: See `~/.claude/workflows/intelligent-tools-strategy.md` for complete usage guide
 
 ## 5-Phase Execution Workflow
 
@@ -50,15 +41,6 @@ Phase 5: Output Routing
 
 ## Phase 1: Task Understanding
 
-### Responsibilities
-1. **Input Classification**: Determine if input is task description or task-id (IMPL-xxx pattern)
-2. **Intent Detection**: Classify as analyze/execute/plan/discuss
-3. **Complexity Assessment**: Rate as simple/medium/complex
-4. **Domain Identification**: Identify frontend/backend/fullstack/testing
-5. **Keyword Extraction**: Extract technical keywords for context search
-
-### Classification Logic
-
 **Intent Detection**:
 - `analyze|review|understand|explain|debug` → **analyze**
 - `implement|add|create|build|fix|refactor` → **execute**
@@ -68,133 +50,71 @@ Phase 5: Output Routing
 **Complexity Scoring**:
 ```
 Score = 0
-+ Keywords match ['system', 'architecture'] → +3
-+ Keywords match ['refactor', 'migrate'] → +2
-+ Keywords match ['component', 'feature'] → +1
-+ Multiple tech stacks identified → +2
-+ Critical systems ['auth', 'payment', 'security'] → +2
++ ['system', 'architecture'] → +3
++ ['refactor', 'migrate'] → +2
++ ['component', 'feature'] → +1
++ Multiple tech stacks → +2
++ ['auth', 'payment', 'security'] → +2
 
-Score ≥ 5 → Complex
-Score ≥ 2 → Medium
-Score < 2 → Simple
+≥5 Complex | ≥2 Medium | <2 Simple
 ```
 
-**Keyword Extraction Categories**:
-- **Domains**: auth, api, database, ui, component, service, middleware
-- **Technologies**: react, typescript, node, express, jwt, oauth, graphql
-- **Actions**: implement, refactor, optimize, test, debug
+**Extract Keywords**: domains (auth, api, database, ui), technologies (react, typescript, node), actions (implement, refactor, test)
 
 ---
 
 ## Phase 2: Context Discovery
 
-### Context Discovery Strategy
-
-**1. Project Structure Analysis**:
+**1. Project Structure**:
 ```bash
 ~/.claude/scripts/get_modules_by_depth.sh
 ```
-Output: Module hierarchy and organization
 
-**2. Content Search (ripgrep)**:
+**2. Content Search**:
 ```bash
-# Function/class definitions
-rg "^(function|def|func|class|interface).*{keyword}" \
-   --type-add 'source:*.{ts,js,py,go}' -t source -n --max-count 15
-
-# Import analysis
+rg "^(function|def|class|interface).*{keyword}" -t source -n --max-count 15
 rg "^(import|from|require).*{keyword}" -t source | head -15
-
-# Test files
-find . \( -name "*{keyword}*test*" -o -name "*{keyword}*spec*" \) \
-   -type f | grep -E "\.(js|ts|py|go)$" | head -10
+find . -name "*{keyword}*test*" -type f | head -10
 ```
 
-**3. External Research (MCP Exa - Optional)**:
+**3. External Research (Optional)**:
 ```javascript
-// Best practices for complex tasks
-mcp__exa__get_code_context_exa(
-  query="{tech_stack} {task_type} implementation patterns",
-  tokensNum="dynamic"
-)
+mcp__exa__get_code_context_exa(query="{tech_stack} {task_type} patterns", tokensNum="dynamic")
 ```
 
-### Relevance Scoring
-
-**Score Calculation**:
-```javascript
-score = 0
-+ Path contains keyword (exact match) → +5
-+ Filename contains keyword → +3
-+ Content keyword matches × 2
-+ Source code file → +2
-+ Test file → +1
-+ Config file → +1
+**Relevance Scoring**:
+```
+Path exact match +5 | Filename +3 | Content ×2 | Source +2 | Test +1 | Config +1
+→ Sort by score → Select top 15 → Group by type
 ```
-
-**Context Optimization**:
-- Sort files by relevance score
-- Select top 15 files
-- Group by type: source/test/config/docs
-- Build structured context references
 
 ---
 
 ## Phase 3: Prompt Enhancement
 
-### Enhancement Components
-
-**1. Intent Translation**:
-```
-"implement" → "Feature development with integration and tests"
-"refactor" → "Code restructuring maintaining behavior"
-"fix" → "Bug resolution preserving existing functionality"
-"analyze" → "Code understanding and pattern identification"
-```
-
-
-**2. Context Assembly**:
+**1. Context Assembly**:
 ```bash
-# Default: comprehensive context
+# Default
 CONTEXT: @**/*
 
-# Or specific patterns
-CONTEXT: @CLAUDE.md @{discovered_file1} @{discovered_file2} ...
+# Specific patterns
+CONTEXT: @CLAUDE.md @src/**/* @*.ts
 
-# Cross-directory references (requires --include-directories)
+# Cross-directory (requires --include-directories)
 CONTEXT: @**/* @../shared/**/* @../types/**/*
-
-## Discovered Context
-- **Project Structure**: {module_summary}
-- **Relevant Files**: {top_files_with_scores}
-- **Code Patterns**: {identified_patterns}
-- **Dependencies**: {tech_stack}
-- **Session Memory**: {conversation_context}
-
-## External Research
-{optional_best_practices_from_exa}
 ```
 
-**Context Pattern Guidelines**:
-- **Default**: Use `@**/*` for comprehensive context
-- **Specific files**: `@src/**/*` or `@*.ts @*.tsx`
-- **With docs**: `@CLAUDE.md @**/*CLAUDE.md`
-- **Cross-directory**: Must use `--include-directories` parameter (see Command Construction)
-
-**3. Template Selection**:
+**2. Template Selection** (`~/.claude/workflows/cli-templates/prompts/`):
 ```
-intent=analyze → ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt
-intent=execute + complex → ~/.claude/workflows/cli-templates/prompts/development/feature.txt
-intent=plan → ~/.claude/workflows/cli-templates/prompts/planning/task-breakdown.txt
+analyze → analysis/code-execution-tracing.txt | analysis/pattern.txt
+execute → development/feature.txt
+plan → planning/architecture-planning.txt | planning/task-breakdown.txt
+bug-fix → development/bug-diagnosis.txt
 ```
 
-**3a. RULES Field Guidelines**:
-
-When using `$(cat ...)` for template loading:
-- **Template reference only**: Use `$(cat ...)` directly, do NOT read template content first
-- **NEVER use escape characters**: `\$`, `\"`, `\'` will break command substitution
-- **Correct**: `RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt)`
-- **Wrong**: `RULES: \$(cat ...)` or `RULES: $(cat \"...\")`
+**3. RULES Field**:
+- Use `$(cat ~/.claude/workflows/cli-templates/prompts/{path}.txt)` directly
+- NEVER escape: `\$`, `\"`, `\'` breaks command substitution
 
 **4. Structured Prompt**:
 ```bash
@@ -202,10 +122,6 @@ PURPOSE: {enhanced_intent}
 TASK: {specific_task_with_details}
 MODE: {analysis|write|auto}
 CONTEXT: {structured_file_references}
-
-## Discovered Context Summary
-{context_from_phase_2}
-
 EXPECTED: {clear_output_expectations}
 RULES: $(cat {selected_template}) | {constraints}
 ```
@@ -214,298 +130,141 @@ RULES: $(cat {selected_template}) | {constraints}
 
 ## Phase 4: Tool Selection & Execution
 
-### Tool Selection Logic
-
+**Auto-Selection**:
 ```
-IF intent = 'analyze' OR 'plan':
-    tool = 'gemini'  # Large context, pattern recognition
-    mode = 'analysis'
-
-ELSE IF intent = 'execute':
-    IF complexity = 'simple' OR 'medium':
-        tool = 'gemini'  # Fast, good for straightforward tasks
-        mode = 'write'
-    ELSE IF complexity = 'complex':
-        tool = 'codex'  # Autonomous development
-        mode = 'auto'
-
-ELSE IF intent = 'discuss':
-    tool = 'multi'  # Gemini + Codex + synthesis
-    mode = 'discussion'
-
-# User --tool flag overrides auto-selection
+analyze|plan → gemini (qwen fallback) + mode=analysis
+execute (simple|medium) → gemini (qwen fallback) + mode=write
+execute (complex) → codex + mode=auto
+discuss → multi (gemini + codex parallel)
 ```
 
-### Model Selection
+**Models**:
+- Gemini: `gemini-2.5-pro` (analysis), `gemini-2.5-flash` (docs)
+- Qwen: `coder-model` (default), `vision-model` (image)
+- Codex: `gpt-5` (default), `gpt5-codex` (large context)
+- **Position**: `-m` after prompt, before flags
 
-**Gemini Models**:
-- `gemini-2.5-pro` - Analysis tasks (default)
-- `gemini-2.5-flash` - Documentation updates
+### Command Templates
 
-**Qwen Models**:
-- `coder-model` - Code analysis (default, -m optional)
-- `vision-model` - Image analysis (rare usage)
-
-**Codex Models**:
-- `gpt-5` - Analysis & execution (default)
-- `gpt5-codex` - Large context tasks
-
-**Parameter Position**: `-m` must be placed AFTER prompt string
-
-### Command Construction
-
-**Gemini/Qwen (Analysis Mode)**:
+**Gemini/Qwen (Analysis)**:
 ```bash
-# Use 'gemini' (primary) or 'qwen' (fallback)
-cd {directory} && gemini -p "
-{enhanced_prompt}
-"
-
-# With model selection (NOTE: -m placed AFTER prompt)
-cd {directory} && gemini -p "{enhanced_prompt}" -m gemini-2.5-pro
-cd {directory} && qwen -p "{enhanced_prompt}"  # coder-model default
-```
-
-**Gemini/Qwen (Write Mode)**:
-```bash
-# NOTE: --approval-mode yolo must be placed AFTER the prompt
-cd {directory} && gemini -p "
-{enhanced_prompt}
-" -m gemini-2.5-flash --approval-mode yolo
-
-# Fallback to Qwen
-cd {directory} && qwen -p "{enhanced_prompt}" --approval-mode yolo
-```
-
-**Codex (Auto Mode)**:
-```bash
-# NOTE: -m, --skip-git-repo-check and -s danger-full-access must be placed at command END
-codex -C {directory} --full-auto exec "
-{enhanced_prompt}
-" -m gpt-5 --skip-git-repo-check -s danger-full-access
-```
-
-**Codex (Resume for Related Tasks)**:
-```bash
-# Parameter Position: resume --last must be placed AFTER prompt at command END
-codex --full-auto exec "
-{continuation_prompt}
-" resume --last --skip-git-repo-check -s danger-full-access
-```
-
-**Cross-Directory Context (Gemini/Qwen)**:
-```bash
-# When CONTEXT references external directories, use --include-directories
-# TWO-STEP REQUIREMENT: 
-# Step 1: Reference in CONTEXT (@../shared/**/*) 
-# Step 2: Add --include-directories parameter
-cd src/auth && gemini -p "
+cd {dir} && gemini -p "
 PURPOSE: {goal}
-CONTEXT: @**/* @../shared/**/* @../types/**/*
-...
-" --include-directories ../shared,../types
+TASK: {task}
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: {output}
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt)
+" -m gemini-2.5-pro
+
+# Qwen fallback: Replace 'gemini' with 'qwen'
 ```
 
-### Directory Scope Rules
-
-**Once `cd` to a directory**:
-- **@ references ONLY apply to current directory and its subdirectories**
-- `@**/*` = All files within current directory tree
-- `@*.ts` = TypeScript files in current directory tree
-- `@src/**/*` = Files within src subdirectory (if exists)
-- **CANNOT reference parent or sibling directories via @ alone**
-
-**To reference files outside current directory**:
-- **Step 1**: Add `--include-directories` parameter
-- **Step 2**: Explicitly reference in CONTEXT field with @ patterns
-- **⚠️ BOTH steps are MANDATORY**
-- **Rule**: If CONTEXT contains `@../dir/**/*`, command MUST include `--include-directories ../dir`
-
-### Timeout Configuration
-
-```javascript
-baseTimeout = {
-  simple: 20 * 60 * 1000,   // 20min
-  medium: 40 * 60 * 1000,   // 40min
-  complex: 60 * 60 * 1000   // 60min
-}
-
-if (tool === 'codex') {
-  timeout = baseTimeout * 1.5
-}
+**Gemini/Qwen (Write)**:
+```bash
+cd {dir} && gemini -p "..." -m gemini-2.5-flash --approval-mode yolo
 ```
 
+**Codex (Auto)**:
+```bash
+codex -C {dir} --full-auto exec "..." -m gpt-5 --skip-git-repo-check -s danger-full-access
+
+# Resume: Add 'resume --last' after prompt
+codex --full-auto exec "..." resume --last -m gpt-5 --skip-git-repo-check -s danger-full-access
+```
+
+**Cross-Directory** (Gemini/Qwen):
+```bash
+cd src/auth && gemini -p "CONTEXT: @**/* @../shared/**/*" --include-directories ../shared
+```
+
+**Directory Scope**:
+- `@` only references current directory + subdirectories
+- External dirs: MUST use `--include-directories` + explicit CONTEXT reference
+
+**Timeout**: Simple 20min | Medium 40min | Complex 60min (Codex ×1.5)
+
 ---
 
 ## Phase 5: Output Routing
 
-### Session Detection
-
-```javascript
-// Check for active session
-activeSession = bash("find .workflow/ -name '.active-*' -type f")
-
-if (activeSession.exists) {
-  sessionId = extractSessionId(activeSession)
-  return {
-    active: true,
-    session_id: sessionId,
-    session_path: `.workflow/${sessionId}/`
-  }
-}
+**Session Detection**:
+```bash
+find .workflow/ -name '.active-*' -type f
 ```
 
-### Output Paths
-
-**Active Session**:
-```
-.workflow/WFS-{id}/.chat/{agent}-{timestamp}.md
-.workflow/WFS-{id}/.summaries/{task-id}-summary.md  // if task-id
-```
-
-**Scratchpad (No Session)**:
-```
-.workflow/.scratchpad/{agent}-{description}-{timestamp}.md
-```
-
-### Execution Log Structure
+**Output Paths**:
+- **With session**: `.workflow/WFS-{id}/.chat/{agent}-{timestamp}.md`
+- **No session**: `.workflow/.scratchpad/{agent}-{description}-{timestamp}.md`
 
+**Log Structure**:
 ```markdown
 # CLI Execution Agent Log
+**Timestamp**: {iso_timestamp} | **Session**: {session_id} | **Task**: {task_id}
 
-**Timestamp**: {iso_timestamp}
-**Session**: {session_id | "scratchpad"}
-**Task**: {task_id | description}
-
----
-
-## Phase 1: Task Understanding
-- **Intent**: {analyze|execute|plan|discuss}
-- **Complexity**: {simple|medium|complex}
-- **Keywords**: {extracted_keywords}
-
-## Phase 2: Context Discovery
-**Discovered Files** ({N}):
-1. {file} (score: {score}) - {description}
-
-**Patterns**: {identified_patterns}
-**Dependencies**: {tech_stack}
-
+## Phase 1: Intent {intent} | Complexity {complexity} | Keywords {keywords}
+## Phase 2: Files ({N}) | Patterns {patterns} | Dependencies {deps}
 ## Phase 3: Enhanced Prompt
-```
-{full_enhanced_prompt}
-```
-
-## Phase 4: Execution
-**Tool**: {gemini|codex|qwen}
-**Command**:
-```bash
-{executed_command}
-```
-
-**Result**: {success|partial|failed}
-**Duration**: {elapsed_time}
-
-## Phase 5: Output
-- Log: {log_path}
-- Summary: {summary_path | N/A}
-
-## Next Steps
-{recommended_actions}
+{full_prompt}
+## Phase 4: Tool {tool} | Command {cmd} | Result {status} | Duration {time}
+## Phase 5: Log {path} | Summary {summary_path}
+## Next Steps: {actions}
 ```
 
 ---
 
-## MCP Integration Guidelines
+## Error Handling
 
-### Exa Research Usage
-
-**Best Practices**:
-```javascript
-mcp__exa__get_code_context_exa(
-  query="TypeScript authentication JWT patterns",
-  tokensNum="dynamic"
-)
+**Tool Fallback**:
+```
+Gemini unavailable → Qwen
+Codex unavailable → Gemini/Qwen write mode
 ```
 
-**When to Use Exa**:
-- Complex tasks requiring best practices
-- Unfamiliar technology stack
-- Architecture design decisions
-- Performance optimization
+**Gemini 429**: Check results exist → success (ignore error) | no results → retry → Qwen
+
+**MCP Exa Unavailable**: Fallback to local search (find/rg)
+
+**Timeout**: Collect partial → save intermediate → suggest decomposition
 
 ---
 
-## Error Handling & Recovery
+## Quality Checklist
 
-### Graceful Degradation
-
-**MCP Exa Unavailable**:
-```bash
-# Fallback to local search only
-find . -name "*{keyword}*" -type f | grep -v node_modules
-rg "{keyword}" --type ts --max-count 20
-```
-
-**Tool Unavailable**:
-```
-Gemini unavailable → Try Qwen
-Codex unavailable → Try Gemini with write mode
-All tools unavailable → Report error
-```
-
-**Timeout Handling**:
-- Collect partial results
-- Save intermediate output
-- Report completion status
-- Suggest task decomposition
-
----
-
-## Quality Standards
-
-### Execution Checklist
-
-Before completing execution:
-- [ ] Context discovery successful (≥3 relevant files)
-- [ ] Enhanced prompt contains specific details
-- [ ] Appropriate tool selected
-- [ ] CLI execution completed
-- [ ] Output properly routed
-- [ ] Session state updated (if active session)
+- [ ] Context ≥3 files
+- [ ] Enhanced prompt detailed
+- [ ] Tool selected
+- [ ] Execution complete
+- [ ] Output routed
+- [ ] Session updated
 - [ ] Next steps documented
 
-### Performance Targets
-
-- **Phase 1**: 1-3 seconds
-- **Phase 2**: 5-15 seconds (MCP + search)
-- **Phase 3**: 2-5 seconds
-- **Phase 4**: Variable (tool-dependent)
-- **Phase 5**: 1-3 seconds
-
-**Total (excluding Phase 4)**: ~10-25 seconds overhead
+**Performance**: Phase 1-3-5: ~10-25s | Phase 2: 5-15s | Phase 4: Variable
 
 ---
 
-## Key Reminders
+## Templates Reference
 
-**ALWAYS:**
-- Execute all 5 phases systematically
-- Use MCP tools when available
-- Score file relevance objectively
-- Select tools based on complexity and intent
-- Route output to correct location
-- Provide clear next steps
-- Handle errors gracefully with fallbacks
+**Location**: `~/.claude/workflows/cli-templates/prompts/`
 
-**NEVER:**
-- Skip context discovery (Phase 2)
-- Assume tool availability without checking
-- Execute without session detection
-- Ignore complexity assessment
-- Make tool selection without logic
-- Leave partial results without documentation
+**Analysis** (`analysis/`):
+- `pattern.txt` - Code pattern analysis
+- `architecture.txt` - System architecture review
+- `code-execution-tracing.txt` - Execution path tracing and debugging
+- `security.txt` - Security assessment
+- `quality.txt` - Code quality review
 
+**Development** (`development/`):
+- `feature.txt` - Feature implementation
+- `refactor.txt` - Refactoring tasks
+- `testing.txt` - Test generation
+- `bug-diagnosis.txt` - Bug root cause analysis and fix suggestions
 
-### Windows Path Format Guidelines
-- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`
+**Planning** (`planning/`):
+- `task-breakdown.txt` - Task decomposition
+- `architecture-planning.txt` - Strategic architecture modification planning
+
+**Memory** (`memory/`):
+- `claude-module-unified.txt` - Universal module/file documentation
+
+---

.claude/agents/doc-generator.md

@@ -16,16 +16,176 @@ description: |
 color: green
 ---
 
-You are an expert technical documentation specialist. Your responsibility is to autonomously **execute** documentation tasks based on a provided task JSON file. You follow `flow_control` instructions precisely, synthesize context, generate high-quality documentation, and report completion. You do not make planning decisions.
+You are an expert technical documentation specialist. Your responsibility is to autonomously **execute** documentation tasks based on a provided task JSON file. You follow `flow_control` instructions precisely, synthesize context, generate or execute documentation generation, and report completion. You do not make planning decisions.
+
+## Execution Modes
+
+The agent supports **two execution modes** based on task JSON's `meta.cli_execute` field:
+
+1. **Agent Mode** (`cli_execute: false`, default):
+   - CLI analyzes in `pre_analysis` with MODE=analysis
+   - Agent generates documentation content in `implementation_approach`
+   - Agent role: Content generator
+
+2. **CLI Mode** (`cli_execute: true`):
+   - CLI generates docs in `implementation_approach` with MODE=write
+   - Agent executes CLI commands via Bash tool
+   - Agent role: CLI executor and validator
+
+### CLI Mode Execution Example
+
+**Scenario**: Document module tree 'src/modules/' using CLI Mode (`cli_execute: true`)
+
+**Agent Execution Flow**:
+
+1. **Mode Detection**:
+   ```
+   Agent reads meta.cli_execute = true → CLI Mode activated
+   ```
+
+2. **Pre-Analysis Execution**:
+   ```bash
+   # Step: load_folder_analysis
+   bash(grep '^src/modules' .workflow/WFS-docs-20240120/.process/folder-analysis.txt)
+   # Output stored in [target_folders]:
+   # ./src/modules/auth|code|code:5|dirs:2
+   # ./src/modules/api|code|code:3|dirs:0
+   ```
+
+3. **Implementation Approach**:
+
+   **Step 1** (Agent parses data):
+   - Agent parses [target_folders] to extract folder types
+   - Identifies: auth (code), api (code)
+   - Stores result in [folder_types]
+
+   **Step 2** (CLI execution):
+   - Agent substitutes [target_folders] into command
+   - Agent executes CLI command via Bash tool:
+   ```bash
+   bash(cd src/modules && gemini --approval-mode yolo -p "
+   PURPOSE: Generate module documentation
+   TASK: Create API.md and README.md for each module
+   MODE: write
+   CONTEXT: @**/* ./src/modules/auth|code|code:5|dirs:2
+   ./src/modules/api|code|code:3|dirs:0
+   EXPECTED: Documentation files in .workflow/docs/my_project/src/modules/
+   RULES: $(cat ~/.claude/workflows/cli-templates/prompts/documentation/module-documentation.txt) | Mirror source structure
+   ")
+   ```
+
+4. **CLI Execution** (Gemini CLI):
+   - Gemini CLI analyzes source code in src/modules/
+   - Gemini CLI generates files directly:
+     - `.workflow/docs/my_project/src/modules/auth/API.md`
+     - `.workflow/docs/my_project/src/modules/auth/README.md`
+     - `.workflow/docs/my_project/src/modules/api/API.md`
+     - `.workflow/docs/my_project/src/modules/api/README.md`
+
+5. **Agent Validation**:
+   ```bash
+   # Verify all target files exist
+   bash(find .workflow/docs/my_project/src/modules -name "*.md" | wc -l)
+   # Expected: 4 files
+
+   # Check file content is not empty
+   bash(find .workflow/docs/my_project/src/modules -name "*.md" -exec wc -l {} \;)
+   ```
+
+6. **Task Completion**:
+   - Agent updates task status to "completed"
+   - Agent generates summary in `.summaries/IMPL-001-summary.md`
+   - Agent updates TODO_LIST.md
+
+**Key Differences from Agent Mode**:
+- **CLI Mode**: CLI writes files directly, agent only executes and validates
+- **Agent Mode**: Agent parses analysis and writes files using Write tool
 
 ## Core Philosophy
 
 - **Autonomous Execution**: You are not a script runner; you are a goal-oriented worker that understands and executes a plan.
+- **Mode-Aware**: You adapt execution strategy based on `meta.cli_execute` mode (Agent Mode vs CLI Mode).
 - **Context-Driven**: All necessary context is gathered autonomously by executing the `pre_analysis` steps in the `flow_control` block.
 - **Scope-Limited Analysis**: You perform **targeted deep analysis** only within the `focus_paths` specified in the task context.
-- **Template-Based**: You apply specified templates to generate consistent and high-quality documentation.
+- **Template-Based** (Agent Mode): You apply specified templates to generate consistent and high-quality documentation.
+- **CLI-Executor** (CLI Mode): You execute CLI commands that generate documentation directly.
 - **Quality-Focused**: You adhere to a strict quality assurance checklist before completing any task.
 
+## Documentation Quality Principles
+
+### 1. Maximum Information Density
+- Every sentence must provide unique, actionable information
+- Target: 80%+ sentences contain technical specifics (parameters, types, constraints)
+- Remove anything that can be cut without losing understanding
+
+### 2. Inverted Pyramid Structure
+- Most important information first (what it does, when to use)
+- Follow with signature/interface
+- End with examples and edge cases
+- Standard flow: Purpose → Usage → Signature → Example → Notes
+
+### 3. Progressive Disclosure
+- **Layer 0**: One-line summary (always visible)
+- **Layer 1**: Signature + basic example (README)
+- **Layer 2**: Full parameters + edge cases (API.md)
+- **Layer 3**: Implementation + architecture (ARCHITECTURE.md)
+- Use cross-references instead of duplicating content
+
+### 4. Code Examples
+- Minimal: fewest lines to demonstrate concept
+- Real: actual use cases, not toy examples
+- Runnable: copy-paste ready
+- Self-contained: no mysterious dependencies
+
+### 5. Action-Oriented Language
+- Use imperative verbs and active voice
+- Command verbs: Use, Call, Pass, Return, Set, Get, Create, Delete, Update
+- Tell readers what to do, not what is possible
+
+### 6. Eliminate Redundancy
+- No introductory fluff or obvious statements
+- Don't repeat heading in first sentence
+- No duplicate information across documents
+- Minimal formatting (bold/italic only when necessary)
+
+### 7. Document-Specific Guidelines
+
+**API.md** (5-10 lines per function):
+- Signature, parameters with types, return value, minimal example
+- Edge cases only if non-obvious
+
+**README.md** (30-100 lines):
+- Purpose (1-2 sentences), when to use, quick start, link to API.md
+- No architecture details (link to ARCHITECTURE.md)
+
+**ARCHITECTURE.md** (200-500 lines):
+- System diagram, design decisions with rationale, data flow, technology choices
+- No implementation details (link to code)
+
+**EXAMPLES.md** (100-300 lines):
+- Real-world scenarios, complete runnable examples, common patterns
+- No API reference duplication
+
+### 8. Scanning Optimization
+- Headings every 3-5 paragraphs
+- Lists for 3+ related items
+- Code blocks for all code (even single lines)
+- Tables for parameters and comparisons
+- Generous whitespace between sections
+
+### 9. Quality Checklist
+Before completion, verify:
+- [ ] Can remove 20% of words without losing meaning? (If yes, do it)
+- [ ] 80%+ sentences are technically specific?
+- [ ] First paragraph answers "what" and "when"?
+- [ ] Reader can find any info in <10 seconds?
+- [ ] Most important info in first screen?
+- [ ] Examples runnable without modification?
+- [ ] No duplicate information across files?
+- [ ] No empty or obvious statements?
+- [ ] Headings alone convey the flow?
+- [ ] All code blocks syntactically highlighted?
+
 ## Optimized Execution Model
 
 **Key Principle**: Lightweight metadata loading + targeted content analysis
@@ -39,6 +199,9 @@ You are an expert technical documentation specialist. Your responsibility is to
 ### 1. Task Ingestion
 - **Input**: A single task JSON file path.
 - **Action**: Load and parse the task JSON. Validate the presence of `id`, `title`, `status`, `meta`, `context`, and `flow_control`.
+- **Mode Detection**: Check `meta.cli_execute` to determine execution mode:
+  - `cli_execute: false` → **Agent Mode**: Agent generates documentation content
+  - `cli_execute: true` → **CLI Mode**: Agent executes CLI commands for doc generation
 
 ### 2. Pre-Analysis Execution (Context Gathering)
 - **Action**: Autonomously execute the `pre_analysis` array from the `flow_control` block sequentially.
@@ -67,6 +230,7 @@ You are an expert technical documentation specialist. Your responsibility is to
 
 ### 3. Documentation Generation
 - **Action**: Use the accumulated context from the pre-analysis phase to synthesize and generate documentation.
+- **Mode Detection**: Check `meta.cli_execute` field to determine execution mode.
 - **Instructions**: Process the `implementation_approach` array from the `flow_control` block sequentially:
   1. **Array Structure**: `implementation_approach` is an array of step objects
   2. **Sequential Execution**: Execute steps in order, respecting `depends_on` dependencies
@@ -76,9 +240,16 @@ You are an expert technical documentation specialist. Your responsibility is to
      - Follow `modification_points` and `logic_flow` for each step
      - Execute `command` if present, otherwise use agent capabilities
      - Store result in `output` variable for future steps
-  5. **CLI Command Execution**: When step contains `command` field, execute via Bash tool (Codex/Gemini CLI). For Codex with dependencies, use `resume --last` flag.
-- **Templates**: Apply templates as specified in `meta.template` or step-level templates.
-- **Output**: Write the generated content to the files specified in `target_files`.
+  5. **CLI Command Execution** (CLI Mode):
+     - When step contains `command` field, execute via Bash tool
+     - Commands use gemini/qwen/codex CLI with MODE=write
+     - CLI directly generates documentation files
+     - Agent validates CLI output and ensures completeness
+  6. **Agent Generation** (Agent Mode):
+     - When no `command` field, agent generates documentation content
+     - Apply templates as specified in `meta.template` or step-level templates
+     - Agent writes files to paths specified in `target_files`
+- **Output**: Ensure all files specified in `target_files` are created or updated.
 
 ### 4. Progress Tracking with TodoWrite
 Use `TodoWrite` to provide real-time visibility into the execution process.
@@ -140,9 +311,13 @@ Before completing the task, you must verify the following:
 ## Key Reminders
 
 **ALWAYS**:
+- **Detect Mode**: Check `meta.cli_execute` to determine execution mode (Agent or CLI).
 - **Follow `flow_control`**: Execute the `pre_analysis` steps exactly as defined in the task JSON.
 - **Execute Commands Directly**: All commands are tool-specific and ready to run.
 - **Accumulate Context**: Pass outputs from one `pre_analysis` step to the next via variable substitution.
+- **Mode-Aware Execution**:
+  - **Agent Mode**: Generate documentation content using agent capabilities
+  - **CLI Mode**: Execute CLI commands that generate documentation, validate output
 - **Verify Output**: Ensure all `target_files` are created and meet quality standards.
 - **Update Progress**: Use `TodoWrite` to track each step of the execution.
 - **Generate a Summary**: Create a detailed summary upon task completion.
@@ -151,4 +326,5 @@ Before completing the task, you must verify the following:
 - **Make Planning Decisions**: Do not deviate from the instructions in the task JSON.
 - **Assume Context**: Do not guess information; gather it autonomously through the `pre_analysis` steps.
 - **Generate Code**: Your role is to document, not to implement.
-- **Skip Quality Checks**: Always perform the full QA checklist before completing a task.
+- **Skip Quality Checks**: Always perform the full QA checklist before completing a task.
+- **Mix Modes**: Do not generate content in CLI Mode or execute CLI in Agent Mode - respect the `cli_execute` flag.

.claude/agents/test-context-search-agent.md

@@ -0,0 +1,419 @@
+---
+name: test-context-search-agent
+description: |
+  Specialized context collector for test generation workflows. Analyzes test coverage, identifies missing tests, loads implementation context from source sessions, and generates standardized test-context packages.
+
+  Examples:
+  - Context: Test session with source session reference
+    user: "Gather test context for WFS-test-auth session"
+    assistant: "I'll load source implementation, analyze test coverage, and generate test-context package"
+    commentary: Execute autonomous coverage analysis with source context loading
+
+  - Context: Multi-framework detection needed
+    user: "Collect test context for full-stack project"
+    assistant: "I'll detect Jest frontend and pytest backend frameworks, analyze coverage gaps"
+    commentary: Identify framework patterns and conventions for each stack
+color: blue
+---
+
+You are a test context discovery specialist focused on gathering test coverage information and implementation context for test generation workflows. Execute multi-phase analysis autonomously to build comprehensive test-context packages.
+
+## Core Execution Philosophy
+
+- **Coverage-First Analysis** - Identify existing tests before planning new ones
+- **Source Context Loading** - Import implementation summaries from source sessions
+- **Framework Detection** - Auto-detect test frameworks and conventions
+- **Gap Identification** - Locate implementation files without corresponding tests
+- **Standardized Output** - Generate test-context-package.json
+
+## Tool Arsenal
+
+### 1. Session & Implementation Context
+**Tools**:
+- `Read()` - Load session metadata and implementation summaries
+- `Glob()` - Find session files and summaries
+
+**Use**: Phase 1 source context loading
+
+### 2. Test Coverage Discovery
+**Primary (Code-Index MCP)**:
+- `mcp__code-index__find_files(pattern)` - Find test files (*.test.*, *.spec.*)
+- `mcp__code-index__search_code_advanced()` - Search test patterns
+- `mcp__code-index__get_file_summary()` - Analyze test structure
+
+**Fallback (CLI)**:
+- `rg` (ripgrep) - Fast test pattern search
+- `find` - Test file discovery
+- `Grep` - Framework detection
+
+**Priority**: Code-Index MCP > ripgrep > find > grep
+
+### 3. Framework & Convention Analysis
+**Tools**:
+- `Read()` - Load package.json, requirements.txt, etc.
+- `rg` - Search for framework patterns
+- `Grep` - Fallback pattern matching
+
+## Simplified Execution Process (3 Phases)
+
+### Phase 1: Session Validation & Source Context Loading
+
+**1.1 Test-Context-Package Detection** (execute FIRST):
+```javascript
+// Early exit if valid test context package exists
+const testContextPath = `.workflow/${test_session_id}/.process/test-context-package.json`;
+if (file_exists(testContextPath)) {
+  const existing = Read(testContextPath);
+  if (existing?.metadata?.test_session_id === test_session_id) {
+    console.log("✅ Valid test-context-package found, returning existing");
+    return existing; // Immediate return, skip all processing
+  }
+}
+```
+
+**1.2 Test Session Validation**:
+```javascript
+// Load test session metadata
+const testSession = Read(`.workflow/${test_session_id}/workflow-session.json`);
+
+// Validate session type
+if (testSession.meta.session_type !== "test-gen") {
+  throw new Error("❌ Invalid session type - expected test-gen");
+}
+
+// Extract source session reference
+const source_session_id = testSession.meta.source_session;
+if (!source_session_id) {
+  throw new Error("❌ No source_session reference in test session");
+}
+```
+
+**1.3 Source Session Context Loading**:
+```javascript
+// 1. Load source session metadata
+const sourceSession = Read(`.workflow/${source_session_id}/workflow-session.json`);
+
+// 2. Discover implementation summaries
+const summaries = Glob(`.workflow/${source_session_id}/.summaries/*-summary.md`);
+
+// 3. Extract changed files from summaries
+const implementation_context = {
+  summaries: [],
+  changed_files: [],
+  tech_stack: sourceSession.meta.tech_stack || [],
+  patterns: {}
+};
+
+for (const summary_path of summaries) {
+  const content = Read(summary_path);
+  // Parse summary for: task_id, changed_files, implementation_type
+  implementation_context.summaries.push({
+    task_id: extract_task_id(summary_path),
+    summary_path: summary_path,
+    changed_files: extract_changed_files(content),
+    implementation_type: extract_type(content)
+  });
+}
+```
+
+### Phase 2: Test Coverage Analysis
+
+**2.1 Existing Test Discovery**:
+```javascript
+// Method 1: Code-Index MCP (preferred)
+const test_files = mcp__code-index__find_files({
+  patterns: ["*.test.*", "*.spec.*", "*test_*.py", "*_test.go"]
+});
+
+// Method 2: Fallback CLI
+// bash: find . -name "*.test.*" -o -name "*.spec.*" | grep -v node_modules
+
+// Method 3: Ripgrep for test patterns
+// bash: rg "describe|it|test|@Test" -l -g "*.test.*" -g "*.spec.*"
+```
+
+**2.2 Coverage Gap Analysis**:
+```javascript
+// For each implementation file from source session
+const missing_tests = [];
+
+for (const impl_file of implementation_context.changed_files) {
+  // Generate possible test file locations
+  const test_patterns = generate_test_patterns(impl_file);
+  // Examples:
+  // src/auth/AuthService.ts → tests/auth/AuthService.test.ts
+  //                         → src/auth/__tests__/AuthService.test.ts
+  //                         → src/auth/AuthService.spec.ts
+
+  // Check if any test file exists
+  const existing_test = test_patterns.find(pattern => file_exists(pattern));
+
+  if (!existing_test) {
+    missing_tests.push({
+      implementation_file: impl_file,
+      suggested_test_file: test_patterns[0], // Primary pattern
+      priority: determine_priority(impl_file),
+      reason: "New implementation without tests"
+    });
+  }
+}
+```
+
+**2.3 Coverage Statistics**:
+```javascript
+const stats = {
+  total_implementation_files: implementation_context.changed_files.length,
+  total_test_files: test_files.length,
+  files_with_tests: implementation_context.changed_files.length - missing_tests.length,
+  files_without_tests: missing_tests.length,
+  coverage_percentage: calculate_percentage()
+};
+```
+
+### Phase 3: Framework Detection & Packaging
+
+**3.1 Test Framework Identification**:
+```javascript
+// 1. Check package.json / requirements.txt / Gemfile
+const framework_config = detect_framework_from_config();
+
+// 2. Analyze existing test patterns (if tests exist)
+if (test_files.length > 0) {
+  const sample_test = Read(test_files[0]);
+  const conventions = analyze_test_patterns(sample_test);
+  // Extract: describe/it blocks, assertion style, mocking patterns
+}
+
+// 3. Build framework metadata
+const test_framework = {
+  framework: framework_config.name,        // jest, mocha, pytest, etc.
+  version: framework_config.version,
+  test_pattern: determine_test_pattern(),  // **/*.test.ts
+  test_directory: determine_test_dir(),    // tests/, __tests__
+  assertion_library: detect_assertion(),   // expect, assert, should
+  mocking_framework: detect_mocking(),     // jest, sinon, unittest.mock
+  conventions: {
+    file_naming: conventions.file_naming,
+    test_structure: conventions.structure,
+    setup_teardown: conventions.lifecycle
+  }
+};
+```
+
+**3.2 Generate test-context-package.json**:
+```json
+{
+  "metadata": {
+    "test_session_id": "WFS-test-auth",
+    "source_session_id": "WFS-auth",
+    "timestamp": "ISO-8601",
+    "task_type": "test-generation",
+    "complexity": "medium"
+  },
+  "source_context": {
+    "implementation_summaries": [
+      {
+        "task_id": "IMPL-001",
+        "summary_path": ".workflow/WFS-auth/.summaries/IMPL-001-summary.md",
+        "changed_files": ["src/auth/AuthService.ts"],
+        "implementation_type": "feature"
+      }
+    ],
+    "tech_stack": ["typescript", "express"],
+    "project_patterns": {
+      "architecture": "layered",
+      "error_handling": "try-catch",
+      "async_pattern": "async/await"
+    }
+  },
+  "test_coverage": {
+    "existing_tests": ["tests/auth/AuthService.test.ts"],
+    "missing_tests": [
+      {
+        "implementation_file": "src/auth/TokenValidator.ts",
+        "suggested_test_file": "tests/auth/TokenValidator.test.ts",
+        "priority": "high",
+        "reason": "New implementation without tests"
+      }
+    ],
+    "coverage_stats": {
+      "total_implementation_files": 3,
+      "files_with_tests": 2,
+      "files_without_tests": 1,
+      "coverage_percentage": 66.7
+    }
+  },
+  "test_framework": {
+    "framework": "jest",
+    "version": "^29.0.0",
+    "test_pattern": "**/*.test.ts",
+    "test_directory": "tests/",
+    "assertion_library": "expect",
+    "mocking_framework": "jest",
+    "conventions": {
+      "file_naming": "*.test.ts",
+      "test_structure": "describe/it blocks",
+      "setup_teardown": "beforeEach/afterEach"
+    }
+  },
+  "assets": [
+    {
+      "type": "implementation_summary",
+      "path": ".workflow/WFS-auth/.summaries/IMPL-001-summary.md",
+      "relevance": "Source implementation context",
+      "priority": "highest"
+    },
+    {
+      "type": "existing_test",
+      "path": "tests/auth/AuthService.test.ts",
+      "relevance": "Test pattern reference",
+      "priority": "high"
+    },
+    {
+      "type": "source_code",
+      "path": "src/auth/TokenValidator.ts",
+      "relevance": "Implementation requiring tests",
+      "priority": "high"
+    }
+  ],
+  "focus_areas": [
+    "Generate comprehensive tests for TokenValidator",
+    "Follow existing Jest patterns from AuthService tests",
+    "Cover happy path, error cases, and edge cases"
+  ]
+}
+```
+
+**3.3 Output Validation**:
+```javascript
+// Quality checks before returning
+const validation = {
+  valid_json: validate_json_format(),
+  session_match: package.metadata.test_session_id === test_session_id,
+  has_source_context: package.source_context.implementation_summaries.length > 0,
+  framework_detected: package.test_framework.framework !== "unknown",
+  coverage_analyzed: package.test_coverage.coverage_stats !== null
+};
+
+if (!validation.all_passed()) {
+  console.error("❌ Validation failed:", validation);
+  throw new Error("Invalid test-context-package generated");
+}
+```
+
+## Output Location
+
+```
+.workflow/{test_session_id}/.process/test-context-package.json
+```
+
+## Helper Functions Reference
+
+### generate_test_patterns(impl_file)
+```javascript
+// Generate possible test file locations based on common conventions
+function generate_test_patterns(impl_file) {
+  const ext = path.extname(impl_file);
+  const base = path.basename(impl_file, ext);
+  const dir = path.dirname(impl_file);
+
+  return [
+    // Pattern 1: tests/ mirror structure
+    dir.replace('src', 'tests') + '/' + base + '.test' + ext,
+    // Pattern 2: __tests__ sibling
+    dir + '/__tests__/' + base + '.test' + ext,
+    // Pattern 3: .spec variant
+    dir.replace('src', 'tests') + '/' + base + '.spec' + ext,
+    // Pattern 4: Python test_ prefix
+    dir.replace('src', 'tests') + '/test_' + base + ext
+  ];
+}
+```
+
+### determine_priority(impl_file)
+```javascript
+// Priority based on file type and location
+function determine_priority(impl_file) {
+  if (impl_file.includes('/core/') || impl_file.includes('/auth/')) return 'high';
+  if (impl_file.includes('/utils/') || impl_file.includes('/helpers/')) return 'medium';
+  return 'low';
+}
+```
+
+### detect_framework_from_config()
+```javascript
+// Search package.json, requirements.txt, etc.
+function detect_framework_from_config() {
+  const configs = [
+    { file: 'package.json', patterns: ['jest', 'mocha', 'jasmine', 'vitest'] },
+    { file: 'requirements.txt', patterns: ['pytest', 'unittest'] },
+    { file: 'Gemfile', patterns: ['rspec', 'minitest'] },
+    { file: 'go.mod', patterns: ['testify'] }
+  ];
+
+  for (const config of configs) {
+    if (file_exists(config.file)) {
+      const content = Read(config.file);
+      for (const pattern of config.patterns) {
+        if (content.includes(pattern)) {
+          return extract_framework_info(content, pattern);
+        }
+      }
+    }
+  }
+
+  return { name: 'unknown', version: null };
+}
+```
+
+## Error Handling
+
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| Source session not found | Invalid source_session reference | Verify test session metadata |
+| No implementation summaries | Source session incomplete | Complete source session first |
+| No test framework detected | Missing test dependencies | Request user to specify framework |
+| Coverage analysis failed | File access issues | Check file permissions |
+
+## Execution Modes
+
+### Plan Mode (Default)
+- Full Phase 1-3 execution
+- Comprehensive coverage analysis
+- Complete framework detection
+- Generate full test-context-package.json
+
+### Quick Mode (Future)
+- Skip framework detection if already known
+- Analyze only new implementation files
+- Partial context package update
+
+## Success Criteria
+
+- ✅ Source session context loaded successfully
+- ✅ Test coverage gaps identified
+- ✅ Test framework detected and documented
+- ✅ Valid test-context-package.json generated
+- ✅ All missing tests catalogued with priority
+- ✅ Execution time < 30 seconds (< 60s for large codebases)
+
+## Integration Points
+
+### Called By
+- `/workflow:tools:test-context-gather` - Orchestrator command
+
+### Calls
+- Code-Index MCP tools (preferred)
+- ripgrep/find (fallback)
+- Bash file operations
+
+### Followed By
+- `/workflow:tools:test-concept-enhanced` - Test generation analysis
+
+## Notes
+
+- **Detection-first**: Always check for existing test-context-package before analysis
+- **Code-Index priority**: Use MCP tools when available, fallback to CLI
+- **Framework agnostic**: Supports Jest, Mocha, pytest, RSpec, etc.
+- **Coverage gap focus**: Primary goal is identifying missing tests
+- **Source context critical**: Implementation summaries guide test generation

.claude/commands/cli/analyze.md

@@ -1,6 +1,6 @@
 ---
 name: analyze
-description: Quick codebase analysis using CLI tools (codex/gemini/qwen)
+description: Read-only codebase analysis using Gemini (default), Qwen, or Codex with auto-pattern detection and template selection
 argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] analysis target"
 allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*), Task(*)
 ---
@@ -9,142 +9,128 @@ allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*), Task(*)
 
 ## Purpose
 
-Quick codebase analysis using CLI tools. **Analysis only - does NOT modify code**.
+Quick codebase analysis using CLI tools. **Read-only - does NOT modify code**.
 
-**Intent**: Understand code patterns, architecture, and provide insights/recommendations
-**Supported Tools**: codex, gemini (default), qwen
-
-## Core Behavior
-
-1. **Read-Only Analysis**: This command ONLY analyzes code and provides insights
-2. **No Code Modification**: Results are recommendations and analysis reports
-3. **Template-Based**: Automatically selects appropriate analysis template
-4. **Smart Pattern Detection**: Infers relevant files based on analysis target
+**Tool Selection**:
+- **gemini** (default) - Best for code analysis
+- **qwen** - Fallback when Gemini unavailable
+- **codex** - Alternative for deep analysis
 
 ## Parameters
 
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
+- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery
 - `--enhance` - Use `/enhance-prompt` for context-aware enhancement
 - `<analysis-target>` - Description of what to analyze
 
+## Tool Usage
+
+**Gemini** (Primary):
+```bash
+--tool gemini  # or omit (default)
+```
+
+**Qwen** (Fallback):
+```bash
+--tool qwen
+```
+
+**Codex** (Alternative):
+```bash
+--tool codex
+```
+
 ## Execution Flow
 
-### Standard Mode (Default)
-
+### Standard Mode
 1. Parse tool selection (default: gemini)
-2. If `--enhance`: Execute `/enhance-prompt` first to expand user intent
-3. Auto-detect analysis type from keywords → select template
-4. Build command with auto-detected file patterns and `MODE: analysis`
-5. Execute analysis (read-only, no code changes)
-6. Return analysis report with insights and recommendations
+2. Optional: enhance with `/enhance-prompt`
+3. Auto-detect file patterns from keywords
+4. Build command with analysis template
+5. Execute analysis (read-only)
+6. Save results
 
-### Agent Mode (`--agent` flag)
+### Agent Mode (`--agent`)
 
-Delegate task to `cli-execution-agent` for intelligent execution with automated context discovery.
+Delegates to agent for intelligent analysis:
 
-**Agent invocation**:
 ```javascript
 Task(
   subagent_type="cli-execution-agent",
-  description="Analyze codebase with automated context discovery",
+  description="Codebase analysis",
   prompt=`
     Task: ${analysis_target}
     Mode: analyze
-    Tool Preference: ${tool_flag || 'auto-select'}
-    ${enhance_flag ? 'Enhance: true' : ''}
+    Tool: ${tool_flag || 'auto-select'}  // gemini|qwen|codex
+    Enhance: ${enhance_flag || false}
 
-    Agent will autonomously:
-    - Discover relevant files and patterns
-    - Build enhanced analysis prompt
-    - Select optimal tool and execute
-    - Route output to session/scratchpad
+    Agent responsibilities:
+    1. Context Discovery:
+       - Discover relevant files/patterns
+       - Identify analysis scope
+       - Build file context
+
+    2. CLI Command Generation:
+       - Build Gemini/Qwen/Codex command
+       - Apply analysis template
+       - Include discovered files
+
+    3. Execution & Output:
+       - Execute analysis
+       - Generate insights report
+       - Save to .workflow/.chat/ or .scratchpad/
   `
 )
 ```
 
-The agent handles all phases internally (understanding, discovery, enhancement, execution, routing).
+## Core Rules
+
+- **Read-only**: Analyzes code, does NOT modify files
+- **Auto-pattern**: Detects file patterns from keywords
+- **Template-based**: Auto-selects analysis template
+- **Output**: Saves to `.workflow/WFS-[id]/.chat/` or `.scratchpad/`
 
 ## File Pattern Auto-Detection
 
-Keywords trigger specific file patterns (each @ references one pattern):
+Keywords → file patterns:
 - "auth" → `@**/*auth* @**/*user*`
-- "component" → `@src/components/**/* @**/*.component.*`
+- "component" → `@src/components/**/*`
 - "API" → `@**/api/**/* @**/routes/**/*`
 - "test" → `@**/*.test.* @**/*.spec.*`
-- "config" → `@*.config.* @**/config/**/*`
 - Generic → `@src/**/*`
 
-For complex patterns, use `rg` or MCP tools to discover files first, then execute CLI with precise file references.
-
-## Command Template
+## CLI Command Templates
 
+**Gemini/Qwen**:
 ```bash
 cd . && gemini -p "
-PURPOSE: [analysis goal from target]
-TASK: [auto-detected analysis type]
+PURPOSE: [goal]
+TASK: [analysis type]
 MODE: analysis
-CONTEXT: @CLAUDE.md [auto-detected file patterns]
-EXPECTED: Insights, patterns, recommendations (NO code modification)
-RULES: [auto-selected template] | Focus on [analysis aspect]
+CONTEXT: @CLAUDE.md [auto-detected patterns]
+EXPECTED: Insights, recommendations
+RULES: [auto-selected template]
 "
+# Qwen: Replace 'gemini' with 'qwen'
 ```
 
-## Examples
-
-**Basic Analysis (Standard Mode)**:
+**Codex**:
 ```bash
-/cli:analyze "authentication patterns"
-# Executes: Gemini analysis with auth file patterns
-# Returns: Pattern analysis, architecture insights, recommendations
+codex -C . --full-auto exec "
+PURPOSE: [goal]
+TASK: [analysis type]
+MODE: analysis
+CONTEXT: @CLAUDE.md [patterns]
+EXPECTED: Deep insights
+RULES: [template]
+" -m gpt-5 --skip-git-repo-check -s danger-full-access
 ```
 
-**Intelligent Analysis (Agent Mode)**:
-```bash
-/cli:analyze --agent "authentication patterns"
-# Phase 1: Classifies intent=analyze, complexity=simple, keywords=['auth', 'patterns']
-# Phase 2: MCP discovers 12 auth files, identifies patterns
-# Phase 3: Builds enhanced prompt with discovered context
-# Phase 4: Executes Gemini with comprehensive file references
-# Phase 5: Saves execution log with all 5 phases documented
-# Returns: Comprehensive analysis + detailed execution log
-```
+## Output
 
-**Architecture Analysis**:
-```bash
-/cli:analyze --tool qwen -p "component architecture"
-# Executes: Qwen with component file patterns
-# Returns: Architecture review, design patterns, improvement suggestions
-```
-
-**Performance Analysis**:
-```bash
-/cli:analyze --tool codex "performance bottlenecks"
-# Executes: Codex deep analysis with performance focus
-# Returns: Bottleneck identification, optimization recommendations
-```
-
-**Enhanced Analysis**:
-```bash
-/cli:analyze --enhance "fix auth issues"
-# Step 1: Enhance prompt to expand context
-# Step 2: Analysis with expanded context
-# Returns: Root cause analysis, fix recommendations (NO automatic fixes)
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND analysis is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/analyze-[timestamp].md`
-- **No active session OR one-off analysis**:
-  - Save to `.workflow/.scratchpad/analyze-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-auth-system`, analyzing auth patterns → `.chat/analyze-20250105-143022.md`
-- No session, quick security check → `.scratchpad/analyze-security-20250105-143045.md`
+- **With session**: `.workflow/WFS-[id]/.chat/analyze-[timestamp].md`
+- **No session**: `.workflow/.scratchpad/analyze-[desc]-[timestamp].md`
 
 ## Notes
 
-- Command templates, file patterns, and best practices: see intelligent-tools-strategy.md (loaded in memory)
-- Scratchpad files can be promoted to workflow sessions if analysis proves valuable
+- See `intelligent-tools-strategy.md` for detailed tool usage and templates

.claude/commands/cli/chat.md

@@ -1,6 +1,6 @@
 ---
 name: chat
-description: Simple CLI interaction command for direct codebase analysis
+description: Read-only Q&A interaction with Gemini/Qwen/Codex for codebase questions with automatic context inference
 argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] inquiry"
 allowed-tools: SlashCommand(*), Bash(*), Task(*)
 ---
@@ -9,140 +9,117 @@ allowed-tools: SlashCommand(*), Bash(*), Task(*)
 
 ## Purpose
 
-Direct Q&A interaction with CLI tools for codebase analysis. **Analysis only - does NOT modify code**.
+Direct Q&A interaction with CLI tools for codebase analysis. **Read-only - does NOT modify code**.
 
-**Intent**: Ask questions, get explanations, understand codebase structure
-**Supported Tools**: codex, gemini (default), qwen
-
-## Core Behavior
-
-1. **Conversational Analysis**: Direct question-answer interaction about codebase
-2. **Read-Only**: This command ONLY provides information and analysis
-3. **No Code Modification**: Results are explanations and insights
-4. **Flexible Context**: Choose specific files or entire codebase
+**Tool Selection**:
+- **gemini** (default) - Best for Q&A and explanations
+- **qwen** - Fallback when Gemini unavailable
+- **codex** - Alternative for technical deep-dives
 
 ## Parameters
 
+- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery
+- `--enhance` - Enhance inquiry with `/enhance-prompt`
 - `<inquiry>` (Required) - Question or analysis request
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Select CLI tool (default: gemini, ignored in agent mode)
-- `--enhance` - Enhance inquiry with `/enhance-prompt` first
-- `--save-session` - Save interaction to workflow session
+
+## Tool Usage
+
+**Gemini** (Primary):
+```bash
+--tool gemini  # or omit (default)
+```
+
+**Qwen** (Fallback):
+```bash
+--tool qwen
+```
+
+**Codex** (Alternative):
+```bash
+--tool codex
+```
 
 ## Execution Flow
 
-### Standard Mode (Default)
-
+### Standard Mode
 1. Parse tool selection (default: gemini)
-2. If `--enhance`: Execute `/enhance-prompt` to expand user intent
-3. Assemble context: `@CLAUDE.md` + user-specified files or `@**/*` for entire codebase
-4. Execute CLI tool with assembled context (read-only, analysis mode)
-5. Return explanations and insights (NO code changes)
-6. Optionally save to workflow session
+2. Optional: enhance with `/enhance-prompt`
+3. Assemble context: `@CLAUDE.md` + inferred files
+4. Execute Q&A (read-only)
+5. Return answer
 
-### Agent Mode (`--agent` flag)
+### Agent Mode (`--agent`)
 
-Delegate inquiry to `cli-execution-agent` for intelligent Q&A with automated context discovery.
+Delegates to agent for intelligent Q&A:
 
-**Agent invocation**:
 ```javascript
 Task(
   subagent_type="cli-execution-agent",
-  description="Answer question with automated context discovery",
+  description="Codebase Q&A",
   prompt=`
     Task: ${inquiry}
-    Mode: analyze (Q&A)
-    Tool Preference: ${tool_flag || 'auto-select'}
+    Mode: chat (Q&A)
+    Tool: ${tool_flag || 'auto-select'}  // gemini|qwen|codex
+    Enhance: ${enhance_flag || false}
 
-    Agent will autonomously:
-    - Discover files relevant to the question
-    - Build Q&A prompt with precise context
-    - Execute and generate comprehensive answer
-    - Save conversation log
+    Agent responsibilities:
+    1. Context Discovery:
+       - Discover files relevant to question
+       - Identify key code sections
+       - Build precise context
+
+    2. CLI Command Generation:
+       - Build Gemini/Qwen/Codex command
+       - Include discovered context
+       - Apply Q&A template
+
+    3. Execution & Output:
+       - Execute Q&A analysis
+       - Generate detailed answer
+       - Save to .workflow/.chat/ or .scratchpad/
   `
 )
 ```
 
-The agent handles all phases internally.
+## Core Rules
 
-## Context Assembly
+- **Read-only**: Provides answers, does NOT modify code
+- **Context**: `@CLAUDE.md` + inferred or all files (`@**/*`)
+- **Output**: Saves to `.workflow/WFS-[id]/.chat/` or `.scratchpad/`
 
-**Always included**: `@CLAUDE.md @**/*CLAUDE.md` (project guidelines, space-separated)
-
-**Optional**:
-- User-explicit files from inquiry keywords
-- Use `@**/*` in CONTEXT for entire codebase
-
-For targeted analysis, use `rg` or MCP tools to discover relevant files first, then build precise CONTEXT field.
-
-## Command Template
+## CLI Command Templates
 
+**Gemini/Qwen**:
 ```bash
 cd . && gemini -p "
-PURPOSE: Answer user inquiry about codebase
-TASK: [user question]
+PURPOSE: Answer question
+TASK: [inquiry]
 MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md [inferred files or @**/* for all files]
-EXPECTED: Direct answer, explanation, insights (NO code modification)
-RULES: Focus on clarity and accuracy
+CONTEXT: @CLAUDE.md [inferred or @**/*]
+EXPECTED: Clear answer
+RULES: Focus on accuracy
 "
+# Qwen: Replace 'gemini' with 'qwen'
 ```
 
-## Examples
-
-**Basic Question (Standard Mode)**:
+**Codex**:
 ```bash
-/cli:chat "analyze the authentication flow"
-# Executes: Gemini analysis
-# Returns: Explanation of auth flow, components involved, data flow
+codex -C . --full-auto exec "
+PURPOSE: Answer question
+TASK: [inquiry]
+MODE: analysis
+CONTEXT: @CLAUDE.md [inferred or @**/*]
+EXPECTED: Detailed answer
+RULES: Technical depth
+" -m gpt-5 --skip-git-repo-check -s danger-full-access
 ```
 
-**Intelligent Q&A (Agent Mode)**:
-```bash
-/cli:chat --agent "how does JWT token refresh work in this codebase"
-# Phase 1: Understands inquiry = JWT refresh mechanism
-# Phase 2: Discovers JWT files, refresh logic, middleware patterns
-# Phase 3: Builds Q&A prompt with discovered implementation details
-# Phase 4: Executes Gemini with precise context for accurate answer
-# Phase 5: Saves conversation log with discovered context
-# Returns: Detailed answer with code references + execution log
-```
+## Output
 
-**Architecture Question**:
-```bash
-/cli:chat --tool qwen -p "how does React component optimization work here"
-# Executes: Qwen architecture analysis
-# Returns: Component structure explanation, optimization patterns used
-```
-
-**Security Analysis**:
-```bash
-/cli:chat --tool codex "review security vulnerabilities"
-# Executes: Codex security analysis
-# Returns: Vulnerability assessment, security recommendations (NO automatic fixes)
-```
-
-**Enhanced Inquiry**:
-```bash
-/cli:chat --enhance "explain the login issue"
-# Step 1: Enhance to expand login context
-# Step 2: Analysis with expanded understanding
-# Returns: Detailed explanation of login flow and potential issues
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND query is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/chat-[timestamp].md`
-- **No active session OR unrelated query**:
-  - Save to `.workflow/.scratchpad/chat-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-api-refactor`, asking about API structure → `.chat/chat-20250105-143022.md`
-- No session, asking about build process → `.scratchpad/chat-build-process-20250105-143045.md`
+- **With session**: `.workflow/WFS-[id]/.chat/chat-[timestamp].md`
+- **No session**: `.workflow/.scratchpad/chat-[desc]-[timestamp].md`
 
 ## Notes
 
-- Command templates and file patterns: see intelligent-tools-strategy.md (loaded in memory)
-- Scratchpad conversations preserved for future reference
+- See `intelligent-tools-strategy.md` for detailed tool usage and templates

.claude/commands/cli/cli-init.md

@@ -1,6 +1,6 @@
 ---
 name: cli-init
-description: Initialize CLI tool configurations (Gemini and Qwen) based on workspace analysis
+description: Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection
 argument-hint: "[--tool gemini|qwen|all] [--output path] [--preview]"
 allowed-tools: Bash(*), Read(*), Write(*), Glob(*)
 ---
@@ -178,7 +178,7 @@ target/
 /cli:cli-init --tool all --output=.config/
 ```
 
-## EXECUTION INSTRUCTIONS ⚡ START HERE
+## EXECUTION INSTRUCTIONS - START HERE
 
 **When this command is triggered, follow these exact steps:**
 
@@ -209,7 +209,7 @@ bash(find . -name "Dockerfile" | head -1)
 ```bash
 # Create .gemini/ directory and settings.json
 mkdir -p .gemini
-echo '{"contextfilename": "CLAUDE.md"}' > .gemini/settings.json
+Write({file_path: '.gemini/settings.json', content: '{"contextfilename": "CLAUDE.md"}'})
 
 # Create .geminiignore file with detected technology rules
 # Backup existing files if present
@@ -219,7 +219,7 @@ echo '{"contextfilename": "CLAUDE.md"}' > .gemini/settings.json
 ```bash
 # Create .qwen/ directory and settings.json
 mkdir -p .qwen
-echo '{"contextfilename": "CLAUDE.md"}' > .qwen/settings.json
+Write({file_path: '.qwen/settings.json', content: '{"contextfilename": "CLAUDE.md"}'})
 
 # Create .qwenignore file with detected technology rules
 # Backup existing files if present

.claude/commands/cli/codex-execute.md

@@ -1,6 +1,6 @@
 ---
 name: codex-execute
-description: Automated task decomposition and execution with Codex using resume mechanism
+description: Multi-stage Codex execution with automatic task decomposition into grouped subtasks using resume mechanism for context continuity
 argument-hint: "[--verify-git] task description or task-id"
 allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
 ---
@@ -257,12 +257,12 @@ TodoWrite({
 
 **When to Resume vs New Session**:
 ```
-✅ RESUME (same group):
+RESUME (same group):
   - Subtasks share files/modules
   - Logical continuation of previous work
   - Same architectural domain
 
-❌ NEW SESSION (different group):
+NEW SESSION (different group):
   - Independent task area
   - Different files/modules
   - Switching architectural domains
@@ -318,7 +318,7 @@ AskUserQuestion({
 
 **During Execution**:
 ```
-📊 Task Flow Diagram:
+Task Flow Diagram:
 [Group A: Auth Core]
   A1: Create user model ──┐
   A2: Add validation     ─┤─► [resume] ─► A3: Database schema
@@ -331,7 +331,7 @@ AskUserQuestion({
   C1: Unit tests ─────────────► [new session]
   C2: Integration tests ──────► [resume]
 
-📋 Task Decomposition:
+Task Decomposition:
   [Group A] 1. Create user model
   [Group A] 2. Add validation logic [resume]
   [Group A] 3. Implement database schema [resume]
@@ -341,28 +341,28 @@ AskUserQuestion({
   [Group C] 7. Unit tests [new session]
   [Group C] 8. Integration tests [resume]
 
-▶️  [Group A] Executing Subtask 1/8: Create user model
+[Group A] Executing Subtask 1/8: Create user model
   Starting new Codex session for Group A...
   [Codex output]
-  ✅ Subtask 1 completed
+  Subtask 1 completed
 
-🔍 Git Verification:
+Git Verification:
   M  src/models/user.ts
-  ✅ Changes verified
+  Changes verified
 
-▶️  [Group A] Executing Subtask 2/8: Add validation logic
+[Group A] Executing Subtask 2/8: Add validation logic
   Resuming Codex session (same group)...
   [Codex output]
-  ✅ Subtask 2 completed
+  Subtask 2 completed
 
-▶️  [Group B] Executing Subtask 4/8: Create auth endpoints
+[Group B] Executing Subtask 4/8: Create auth endpoints
   Starting NEW Codex session for Group B...
   [Codex output]
-  ✅ Subtask 4 completed
+  Subtask 4 completed
 ...
 
-✅ All Subtasks Completed
-📊 Summary: [file references, changes, next steps]
+All Subtasks Completed
+Summary: [file references, changes, next steps]
 ```
 
 **Final Summary**:
@@ -370,8 +370,8 @@ AskUserQuestion({
 # Task Execution Summary: [Task Description]
 
 ## Subtasks Completed
-1. ✅ [Subtask 1]: [files modified]
-2. ✅ [Subtask 2]: [files modified]
+1. [Subtask 1]: [files modified]
+2. [Subtask 2]: [files modified]
 ...
 
 ## Files Modified

.claude/commands/cli/discuss-plan.md

@@ -1,6 +1,6 @@
 ---
 name: discuss-plan
-description: Orchestrates an iterative, multi-model discussion for planning and analysis without implementation.
+description: Multi-round collaborative planning using Gemini, Codex, and Claude synthesis with iterative discussion cycles (read-only, no code changes)
 argument-hint: "[--topic '...'] [--task-id '...'] [--rounds N]"
 allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
 ---
@@ -279,11 +279,11 @@ Each round's output is structured as:
 
 | Command | Models | Rounds | Discussion | Implementation | Use Case |
 |---------|--------|--------|------------|----------------|----------|
-| `/cli:mode:plan` | Gemini | 1 | ❌ NO | ❌ NO | Single-model planning |
-| `/cli:analyze` | Gemini/Qwen | 1 | ❌ NO | ❌ NO | Code analysis |
-| `/cli:execute` | Any | 1 | ❌ NO | ✅ YES | Direct implementation |
-| `/cli:codex-execute` | Codex | 1 | ❌ NO | ✅ YES | Multi-stage implementation |
-| `/cli:discuss-plan` | **Gemini+Codex+Claude** | **Multiple** | ✅ **YES** | ❌ **NO** | **Multi-perspective planning** |
+| `/cli:mode:plan` | Gemini | 1 | NO | NO | Single-model planning |
+| `/cli:analyze` | Gemini/Qwen | 1 | NO | NO | Code analysis |
+| `/cli:execute` | Any | 1 | NO | YES | Direct implementation |
+| `/cli:codex-execute` | Codex | 1 | NO | YES | Multi-stage implementation |
+| `/cli:discuss-plan` | **Gemini+Codex+Claude** | **Multiple** | **YES** | **NO** | **Multi-perspective planning** |
 
 ## Best Practices
 

.claude/commands/cli/execute.md

@@ -1,6 +1,6 @@
 ---
 name: execute
-description: Auto-execution of implementation tasks with YOLO permissions and intelligent context inference
+description: Autonomous code implementation with YOLO auto-approval using Gemini/Qwen/Codex, supports task ID or description input with automatic file pattern detection
 argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] description or task-id"
 allowed-tools: SlashCommand(*), Bash(*), Task(*)
 ---
@@ -27,7 +27,7 @@ Execute implementation tasks with **YOLO permissions** (auto-approves all confir
 ### YOLO Permissions
 Auto-approves: file pattern inference, execution, **file modifications**, summary generation
 
-**⚠️ WARNING**: This command will make actual code changes without manual confirmation
+**WARNING**: This command will make actual code changes without manual confirmation
 
 ### Execution Modes
 
@@ -158,14 +158,14 @@ The agent handles all phases internally, including complexity-based tool selecti
 
 ## Examples
 
-**Basic Implementation (Standard Mode)** (⚠️ modifies code):
+**Basic Implementation (Standard Mode)** (modifies code):
 ```bash
 /cli:execute "implement JWT authentication with middleware"
 # Executes: Creates auth middleware, updates routes, modifies config
 # Result: NEW/MODIFIED code files with JWT implementation
 ```
 
-**Intelligent Implementation (Agent Mode)** (⚠️ modifies code):
+**Intelligent Implementation (Agent Mode)** (modifies code):
 ```bash
 /cli:execute --agent "implement OAuth2 authentication with token refresh"
 # Phase 1: Classifies intent=execute, complexity=complex, keywords=['oauth2', 'auth', 'token', 'refresh']
@@ -176,7 +176,7 @@ The agent handles all phases internally, including complexity-based tool selecti
 # Result: Complete OAuth2 implementation + detailed execution log
 ```
 
-**Enhanced Implementation** (⚠️ modifies code):
+**Enhanced Implementation** (modifies code):
 ```bash
 /cli:execute --enhance "implement JWT authentication"
 # Step 1: Enhance to expand requirements
@@ -184,7 +184,7 @@ The agent handles all phases internally, including complexity-based tool selecti
 # Result: Complete auth system with MODIFIED code files
 ```
 
-**Task Execution** (⚠️ modifies code):
+**Task Execution** (modifies code):
 ```bash
 /cli:execute IMPL-001
 # Reads: .task/IMPL-001.json for requirements
@@ -192,14 +192,14 @@ The agent handles all phases internally, including complexity-based tool selecti
 # Result: Code changes per task definition
 ```
 
-**Codex Implementation** (⚠️ modifies code):
+**Codex Implementation** (modifies code):
 ```bash
 /cli:execute --tool codex "optimize database queries"
 # Executes: Codex with full file access
 # Result: MODIFIED query code, new indexes, updated tests
 ```
 
-**Qwen Code Generation** (⚠️ modifies code):
+**Qwen Code Generation** (modifies code):
 ```bash
 /cli:execute --tool qwen --enhance "refactor auth module"
 # Step 1: Enhanced refactoring plan
@@ -211,11 +211,11 @@ The agent handles all phases internally, including complexity-based tool selecti
 
 | Command | Intent | Code Changes | Auto-Approve |
 |---------|--------|--------------|--------------|
-| `/cli:analyze` | Understand code | ❌ NO | N/A |
-| `/cli:chat` | Ask questions | ❌ NO | N/A |
-| `/cli:execute` | **Implement** | ✅ **YES** | ✅ **YES** |
+| `/cli:analyze` | Understand code | NO | N/A |
+| `/cli:chat` | Ask questions | NO | N/A |
+| `/cli:execute` | **Implement** | **YES** | **YES** |
 
 ## Notes
 
 - Command templates, YOLO mode details, and session management: see intelligent-tools-strategy.md (loaded in memory)
-- **⚠️ Code Modification**: This command modifies code - execution logs document changes made
+- **Code Modification**: This command modifies code - execution logs document changes made

.claude/commands/cli/mode/bug-diagnosis.md

@@ -0,0 +1,130 @@
+---
+name: bug-diagnosis
+description: Read-only bug root cause analysis using Gemini/Qwen/Codex with systematic diagnosis template for fix suggestions
+argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] bug description"
+allowed-tools: SlashCommand(*), Bash(*), Task(*)
+---
+
+# CLI Mode: Bug Diagnosis (/cli:mode:bug-diagnosis)
+
+## Purpose
+
+Systematic bug diagnosis with root cause analysis template (`~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt`).
+
+**Tool Selection**:
+- **gemini** (default) - Best for bug diagnosis
+- **qwen** - Fallback when Gemini unavailable
+- **codex** - Alternative for complex bug analysis
+
+## Parameters
+
+- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery
+- `--enhance` - Enhance bug description with `/enhance-prompt`
+- `--cd "path"` - Target directory for focused diagnosis
+- `<bug-description>` (Required) - Bug description or error details
+
+## Tool Usage
+
+**Gemini** (Primary):
+```bash
+# Uses gemini by default, or specify explicitly
+--tool gemini
+```
+
+**Qwen** (Fallback):
+```bash
+--tool qwen
+```
+
+**Codex** (Alternative):
+```bash
+--tool codex
+```
+
+## Execution Flow
+
+### Standard Mode
+1. Parse tool selection (default: gemini)
+2. Optional: enhance with `/enhance-prompt`
+3. Detect directory from `--cd` or auto-infer
+4. Build command with template
+5. Execute diagnosis (read-only)
+6. Save to `.workflow/WFS-[id]/.chat/`
+
+### Agent Mode (`--agent`)
+
+Delegates to agent for intelligent diagnosis:
+
+```javascript
+Task(
+  subagent_type="cli-execution-agent",
+  description="Bug root cause diagnosis",
+  prompt=`
+    Task: ${bug_description}
+    Mode: bug-diagnosis
+    Tool: ${tool_flag || 'auto-select'}  // gemini|qwen|codex
+    Directory: ${cd_path || 'auto-detect'}
+    Template: ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt
+
+    Agent responsibilities:
+    1. Context Discovery:
+       - Locate error traces and logs
+       - Find related code sections
+       - Identify data flow paths
+
+    2. CLI Command Generation:
+       - Build Gemini/Qwen/Codex command
+       - Include diagnostic context
+       - Apply ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt template
+
+    3. Execution & Output:
+       - Execute root cause analysis
+       - Generate fix suggestions
+       - Save to .workflow/.chat/
+  `
+)
+```
+
+## Core Rules
+
+- **Read-only**: Diagnoses bugs, does NOT modify code
+- **Template**: Uses `~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt` for root cause analysis
+- **Output**: Saves to `.workflow/WFS-[id]/.chat/`
+
+## CLI Command Templates
+
+**Gemini/Qwen** (default, diagnosis only):
+```bash
+cd [dir] && gemini -p "
+PURPOSE: [goal]
+TASK: Root cause analysis
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: Diagnosis, fix plan
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt)
+"
+# Qwen: Replace 'gemini' with 'qwen'
+```
+
+**Codex** (diagnosis + potential fixes):
+```bash
+codex -C [dir] --full-auto exec "
+PURPOSE: [goal]
+TASK: Bug diagnosis
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: Diagnosis, fix suggestions
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt)
+" -m gpt-5 --skip-git-repo-check -s danger-full-access
+```
+
+## Output
+
+- **With session**: `.workflow/WFS-[id]/.chat/bug-diagnosis-[timestamp].md`
+- **No session**: `.workflow/.scratchpad/bug-diagnosis-[desc]-[timestamp].md`
+
+## Notes
+
+- Template: `~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt`
+- See `intelligent-tools-strategy.md` for detailed tool usage

.claude/commands/cli/mode/bug-index.md

@@ -1,163 +0,0 @@
----
-name: bug-index
-description: Bug analysis and fix suggestions using CLI tools
-argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] bug description"
-allowed-tools: SlashCommand(*), Bash(*), Task(*)
----
-
-# CLI Mode: Bug Index (/cli:mode:bug-index)
-
-## Purpose
-
-Systematic bug analysis with diagnostic template (`~/.claude/prompt-templates/bug-fix.md`).
-
-**Supported Tools**: codex, gemini (default), qwen
-**Key Feature**: `--cd` flag for directory-scoped analysis
-
-## Parameters
-
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
-- `--enhance` - Enhance bug description with `/enhance-prompt` first
-- `--cd "path"` - Target directory for focused analysis
-- `<bug-description>` (Required) - Bug description or error message
-
-## Execution Flow
-
-### Standard Mode (Default)
-
-1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
-2. **If `--enhance` flag present**: Execute `/enhance-prompt "[bug-description]"` first
-3. Parse bug description (original or enhanced)
-4. Detect target directory (from `--cd` or auto-infer)
-5. Build command for selected tool with bug-fix template
-6. Execute analysis (read-only, provides fix recommendations)
-7. Save to `.workflow/WFS-[id]/.chat/bug-index-[timestamp].md`
-
-### Agent Mode (`--agent` flag)
-
-Delegate bug analysis to `cli-execution-agent` for intelligent debugging with automated context discovery.
-
-**Agent invocation**:
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Analyze bug with automated context discovery",
-  prompt=`
-    Task: ${bug_description}
-    Mode: debug (bug analysis)
-    Tool Preference: ${tool_flag || 'auto-select'}
-    ${cd_flag ? `Directory Scope: ${cd_path}` : ''}
-    Template: bug-fix
-
-    Agent will autonomously:
-    - Discover bug-related files and error traces
-    - Build debug prompt with bug-fix template
-    - Execute analysis and provide fix recommendations
-    - Save analysis log
-  `
-)
-```
-
-The agent handles all phases internally.
-
-## Core Rules
-
-1. **Analysis Only**: This command analyzes bugs and suggests fixes - it does NOT modify code
-2. **Enhance First (if flagged)**: Execute `/enhance-prompt` before analysis
-3. **Directory Context**: Use `cd` when `--cd` provided or auto-detected
-4. **Template Required**: Always use bug-fix template
-5. **Session Output**: Save analysis results and fix recommendations to session chat
-
-## Analysis Focus (via Template)
-
-- Root cause investigation and diagnosis
-- Code path tracing to locate issues
-- Targeted minimal fix recommendations
-- Impact assessment of proposed changes
-
-## Command Template
-
-```bash
-cd [directory] && gemini -p "
-PURPOSE: [bug analysis goal]
-TASK: Systematic bug analysis and fix recommendations
-MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md [entire codebase in directory]
-EXPECTED: Root cause analysis, code path tracing, targeted fix suggestions
-RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: [description]
-"
-```
-
-## Examples
-
-**Basic Bug Analysis (Standard Mode)**:
-```bash
-/cli:mode:bug-index "null pointer error in login flow"
-# Executes: Gemini with bug-fix template
-# Returns: Root cause analysis, fix recommendations
-```
-
-**Intelligent Bug Analysis (Agent Mode)**:
-```bash
-/cli:mode:bug-index --agent "intermittent token validation failure"
-# Phase 1: Classifies as debug task, extracts keywords ['token', 'validation', 'failure']
-# Phase 2: MCP discovers token validation code, middleware, test files with errors
-# Phase 3: Builds debug prompt with bug-fix template + discovered error patterns
-# Phase 4: Executes Gemini with comprehensive bug context
-# Phase 5: Saves analysis log with detailed fix recommendations
-# Returns: Root cause analysis + code path traces + minimal fix suggestions
-```
-
-**Standard Template Example**:
-```bash
-cd . && gemini -p "
-PURPOSE: Debug authentication null pointer error
-TASK: Identify root cause and provide fix recommendations
-MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md
-EXPECTED: Root cause, code path, minimal fix suggestion, impact assessment
-RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: null pointer in login flow
-"
-```
-
-**Directory-Specific**:
-```bash
-cd src/auth && gemini -p "
-PURPOSE: Fix token validation failure
-TASK: Analyze token validation bug in auth module
-MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md
-EXPECTED: Validation logic analysis, fix recommendation with minimal changes
-RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: token validation fails intermittently
-"
-```
-
-## Bug Investigation Workflow
-
-```bash
-# 1. Find bug-related files
-rg "error_keyword" --files-with-matches
-rg "error|exception" -g "*.ts"
-
-# 2. Execute bug analysis with focused context (analysis only, no code changes)
-/cli:mode:bug-index --cd "src/module" "specific error description"
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND bug is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/bug-index-[timestamp].md`
-- **No active session OR quick debugging**:
-  - Save to `.workflow/.scratchpad/bug-index-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-payment-fix`, analyzing payment bug → `.chat/bug-index-20250105-143022.md`
-- No session, quick null pointer investigation → `.scratchpad/bug-index-null-pointer-20250105-143045.md`
-
-## Notes
-
-- Command templates and file patterns: see intelligent-tools-strategy.md (loaded in memory)
-- Template path: `~/.claude/prompt-templates/bug-fix.md`
-- Uses `@**/*` for in CONTEXT field for comprehensive codebase context

.claude/commands/cli/mode/code-analysis.md

@@ -1,6 +1,6 @@
 ---
 name: code-analysis
-description: Deep code analysis and debugging using CLI tools with specialized template
+description: Read-only execution path tracing using Gemini/Qwen/Codex with specialized analysis template for call flow and optimization
 argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] analysis target"
 allowed-tools: SlashCommand(*), Bash(*), Task(*)
 ---
@@ -9,161 +9,129 @@ allowed-tools: SlashCommand(*), Bash(*), Task(*)
 
 ## Purpose
 
-Systematic code analysis with execution path tracing template (`~/.claude/prompt-templates/code-analysis.md`).
+Systematic code analysis with execution path tracing template (`~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt`).
+
+**Tool Selection**:
+- **gemini** (default) - Best for code analysis and tracing
+- **qwen** - Fallback when Gemini unavailable
+- **codex** - Alternative for complex analysis tasks
 
-**Supported Tools**: codex, gemini (default), qwen
 **Key Feature**: `--cd` flag for directory-scoped analysis
 
 ## Parameters
 
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
+- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery
 - `--enhance` - Enhance analysis target with `/enhance-prompt` first
 - `--cd "path"` - Target directory for focused analysis
 - `<analysis-target>` (Required) - Code analysis target or question
 
+## Tool Usage
+
+**Gemini** (Primary):
+```bash
+/cli:mode:code-analysis --tool gemini "trace auth flow"
+# OR (default)
+/cli:mode:code-analysis "trace auth flow"
+```
+
+**Qwen** (Fallback):
+```bash
+/cli:mode:code-analysis --tool qwen "trace auth flow"
+```
+
+**Codex** (Alternative):
+```bash
+/cli:mode:code-analysis --tool codex "trace auth flow"
+```
+
 ## Execution Flow
 
 ### Standard Mode (Default)
 
-1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
-2. **If `--enhance` flag present**: Execute `/enhance-prompt "[analysis-target]"` first
-3. Parse analysis target (original or enhanced)
-4. Detect target directory (from `--cd` or auto-infer)
-5. Build command for selected tool with code-analysis template
-6. Execute deep analysis (read-only, no code modification)
-7. Save to `.workflow/WFS-[id]/.chat/code-analysis-[timestamp].md`
+1. Parse tool selection (default: gemini)
+2. Optional: enhance analysis target with `/enhance-prompt`
+3. Detect target directory from `--cd` or auto-infer
+4. Build command with template
+5. Execute analysis (read-only)
+6. Save to `.workflow/WFS-[id]/.chat/code-analysis-[timestamp].md`
 
 ### Agent Mode (`--agent` flag)
 
-Delegate code analysis to `cli-execution-agent` for intelligent execution path tracing with automated context discovery.
+Delegates to `cli-execution-agent` for intelligent context discovery and analysis.
+
+## Core Rules
+
+- **Read-only**: Analyzes code, does NOT modify files
+- **Template**: Uses `~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt` for systematic analysis
+- **Output**: Saves to `.workflow/WFS-[id]/.chat/`
+
+## CLI Command Templates
+
+**Gemini/Qwen** (default, read-only analysis):
+```bash
+cd [dir] && gemini -p "
+PURPOSE: [goal]
+TASK: Execution path tracing
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: Trace, call diagram
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt)
+"
+# Qwen: Replace 'gemini' with 'qwen'
+```
+
+**Codex** (analysis + optimization suggestions):
+```bash
+codex -C [dir] --full-auto exec "
+PURPOSE: [goal]
+TASK: Path analysis
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: Trace, optimization
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt)
+" -m gpt-5 --skip-git-repo-check -s danger-full-access
+```
+
+## Agent Execution Context
+
+When `--agent` flag is used, delegate to agent:
 
-**Agent invocation**:
 ```javascript
 Task(
   subagent_type="cli-execution-agent",
-  description="Analyze code execution paths with automated context discovery",
+  description="Code execution path analysis",
   prompt=`
     Task: ${analysis_target}
-    Mode: code-analysis (execution tracing)
-    Tool Preference: ${tool_flag || 'auto-select'}
-    ${cd_flag ? `Directory Scope: ${cd_path}` : ''}
-    Template: code-analysis
+    Mode: code-analysis
+    Tool: ${tool_flag || 'auto-select'}  // gemini|qwen|codex
+    Directory: ${cd_path || 'auto-detect'}
+    Template: ~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt
 
-    Agent will autonomously:
-    - Discover execution paths and call flows
-    - Build analysis prompt with code-analysis template
-    - Execute deep tracing analysis
-    - Generate call diagrams and save log
+    Agent responsibilities:
+    1. Context Discovery:
+       - Identify entry points and call chains
+       - Discover related files (MCP/ripgrep)
+       - Map execution flow paths
+
+    2. CLI Command Generation:
+       - Build Gemini/Qwen/Codex command
+       - Include discovered context
+       - Apply ~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt template
+
+    3. Execution & Output:
+       - Execute analysis with selected tool
+       - Save to .workflow/WFS-[id]/.chat/
   `
 )
 ```
 
-The agent handles all phases internally.
+## Output
 
-## Core Rules
-
-1. **Analysis Only**: This command analyzes code and provides insights - it does NOT modify code
-2. **Tool Selection**: Use `--tool` value or default to gemini
-3. **Enhance First (if flagged)**: Execute `/enhance-prompt` before analysis
-4. **Directory Context**: Use `cd` when `--cd` provided or auto-detected
-5. **Template Required**: Always use code-analysis template
-6. **Session Output**: Save analysis results to session chat
-
-## Analysis Capabilities (via Template)
-
-- **Systematic Code Analysis**: Break down complex code into manageable parts
-- **Execution Path Tracing**: Track variable states and call stacks
-- **Control & Data Flow**: Understand code logic and data transformations
-- **Call Flow Visualization**: Diagram function calling sequences
-- **Logical Reasoning**: Explain "why" behind code behavior
-- **Debugging Insights**: Identify potential bugs or inefficiencies
-
-## Command Template
-
-```bash
-cd [directory] && gemini -p "
-PURPOSE: [analysis goal]
-TASK: Systematic code analysis and execution path tracing
-MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md [entire codebase in directory]
-EXPECTED: Execution trace, call flow diagram, debugging insights
-RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on [aspect]
-"
-```
-
-## Examples
-
-**Basic Code Analysis (Standard Mode)**:
-```bash
-/cli:mode:code-analysis "trace authentication execution flow"
-# Executes: Gemini with code-analysis template
-# Returns: Execution trace, call diagram, debugging insights
-```
-
-**Intelligent Code Analysis (Agent Mode)**:
-```bash
-/cli:mode:code-analysis --agent "trace JWT token validation from request to database"
-# Phase 1: Classifies as deep analysis, keywords ['jwt', 'token', 'validation', 'database']
-# Phase 2: MCP discovers request handler → middleware → service → repository chain
-# Phase 3: Builds analysis prompt with code-analysis template + complete call path
-# Phase 4: Executes Gemini with traced execution paths
-# Phase 5: Saves detailed analysis with call flow diagrams and variable states
-# Returns: Complete execution trace + call diagram + data flow analysis
-```
-
-**Standard Template Example**:
-```bash
-cd . && gemini -p "
-PURPOSE: Trace authentication execution flow
-TASK: Analyze complete auth flow from request to response
-MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md
-EXPECTED: Step-by-step execution trace with call diagram, variable states
-RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on control flow
-"
-```
-
-**Directory-Specific Analysis**:
-```bash
-cd src/auth && gemini -p "
-PURPOSE: Understand JWT token validation logic
-TASK: Trace JWT validation from middleware to service layer
-MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md
-EXPECTED: Validation flow diagram, token lifecycle analysis
-RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on security
-"
-```
-
-## Code Tracing Workflow
-
-```bash
-# 1. Find entry points and related files
-rg "function.*authenticate|class.*AuthService" --files-with-matches
-rg "authenticate|login" -g "*.ts"
-
-# 2. Build call graph understanding
-# entry → middleware → service → repository
-
-# 3. Execute deep analysis (analysis only, no code changes)
-/cli:mode:code-analysis --cd "src" "trace execution from entry point"
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND analysis is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/code-analysis-[timestamp].md`
-- **No active session OR standalone analysis**:
-  - Save to `.workflow/.scratchpad/code-analysis-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-auth-refactor`, analyzing auth flow → `.chat/code-analysis-20250105-143022.md`
-- No session, tracing request lifecycle → `.scratchpad/code-analysis-request-flow-20250105-143045.md`
+- **With session**: `.workflow/WFS-[id]/.chat/code-analysis-[timestamp].md`
+- **No session**: `.workflow/.scratchpad/code-analysis-[desc]-[timestamp].md`
 
 ## Notes
 
-- Command templates and file patterns: see intelligent-tools-strategy.md (loaded in memory)
-- Template path: `~/.claude/prompt-templates/code-analysis.md`
-- Uses `@**/*` for in CONTEXT field for comprehensive code context
+- Template: `~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt`
+- See `intelligent-tools-strategy.md` for detailed tool usage

.claude/commands/cli/mode/plan.md

@@ -1,6 +1,6 @@
 ---
 name: plan
-description: Project planning and architecture analysis using CLI tools
+description: Read-only architecture planning using Gemini/Qwen/Codex with strategic planning template for modification plans and impact analysis
 argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] topic"
 allowed-tools: SlashCommand(*), Bash(*), Task(*)
 ---
@@ -9,159 +9,121 @@ allowed-tools: SlashCommand(*), Bash(*), Task(*)
 
 ## Purpose
 
-Comprehensive planning and architecture analysis with strategic planning template (`~/.claude/prompt-templates/plan.md`).
+Strategic software architecture planning template (`~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt`).
 
-**Supported Tools**: codex, gemini (default), qwen
-**Key Feature**: `--cd` flag for directory-scoped planning
+**Tool Selection**:
+- **gemini** (default) - Best for architecture planning
+- **qwen** - Fallback when Gemini unavailable
+- **codex** - Alternative for implementation planning
 
 ## Parameters
 
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
-- `--enhance` - Enhance topic with `/enhance-prompt` first
+- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery
+- `--enhance` - Enhance task with `/enhance-prompt`
 - `--cd "path"` - Target directory for focused planning
-- `<topic>` (Required) - Planning topic or architectural question
+- `<planning-task>` (Required) - Architecture planning task or modification requirements
+
+## Tool Usage
+
+**Gemini** (Primary):
+```bash
+--tool gemini  # or omit (default)
+```
+
+**Qwen** (Fallback):
+```bash
+--tool qwen
+```
+
+**Codex** (Alternative):
+```bash
+--tool codex
+```
 
 ## Execution Flow
 
-### Standard Mode (Default)
+### Standard Mode
+1. Parse tool selection (default: gemini)
+2. Optional: enhance with `/enhance-prompt`
+3. Detect directory from `--cd` or auto-infer
+4. Build command with template
+5. Execute planning (read-only, no code generation)
+6. Save to `.workflow/WFS-[id]/.chat/`
 
-1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
-2. **If `--enhance` flag present**: Execute `/enhance-prompt "[topic]"` first
-3. Parse topic (original or enhanced)
-4. Detect target directory (from `--cd` or auto-infer)
-5. Build command for selected tool with planning template
-6. Execute analysis (read-only, no code modification)
-7. Save to `.workflow/WFS-[id]/.chat/plan-[timestamp].md`
+### Agent Mode (`--agent`)
 
-### Agent Mode (`--agent` flag)
+Delegates to agent for intelligent planning:
 
-Delegate planning to `cli-execution-agent` for intelligent strategic planning with automated architecture discovery.
-
-**Agent invocation**:
 ```javascript
 Task(
   subagent_type="cli-execution-agent",
-  description="Create strategic plan with automated architecture discovery",
+  description="Architecture modification planning",
   prompt=`
-    Task: ${planning_topic}
-    Mode: plan (strategic planning)
-    Tool Preference: ${tool_flag || 'auto-select'}
-    ${cd_flag ? `Directory Scope: ${cd_path}` : ''}
-    Template: plan
+    Task: ${planning_task}
+    Mode: architecture-planning
+    Tool: ${tool_flag || 'auto-select'}  // gemini|qwen|codex
+    Directory: ${cd_path || 'auto-detect'}
+    Template: ~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt
 
-    Agent will autonomously:
-    - Discover project structure and existing architecture
-    - Build planning prompt with plan template
-    - Execute strategic planning analysis
-    - Generate implementation roadmap and save
+    Agent responsibilities:
+    1. Context Discovery:
+       - Analyze current architecture
+       - Identify affected components
+       - Map dependencies and impacts
+
+    2. CLI Command Generation:
+       - Build Gemini/Qwen/Codex command
+       - Include architecture context
+       - Apply ~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt template
+
+    3. Execution & Output:
+       - Execute strategic planning
+       - Generate modification plan
+       - Save to .workflow/.chat/
   `
 )
 ```
 
-The agent handles all phases internally.
-
 ## Core Rules
 
-1. **Analysis Only**: This command provides planning recommendations and insights - it does NOT modify code
-2. **Enhance First (if flagged)**: Execute `/enhance-prompt` before planning
-3. **Directory Context**: Use `cd` when `--cd` provided or auto-detected
-4. **Template Required**: Always use planning template
-5. **Session Output**: Save analysis results to session chat
+- **Planning only**: Creates modification plans, does NOT generate code
+- **Template**: Uses `~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt` for strategic planning
+- **Output**: Saves to `.workflow/WFS-[id]/.chat/`
 
-## Planning Capabilities (via Template)
-
-- Strategic architecture insights and recommendations
-- Implementation roadmaps and suggestions
-- Key technical decisions analysis
-- Risk assessment
-- Resource planning
-
-## Command Template
+## CLI Command Templates
 
+**Gemini/Qwen** (default, planning only):
 ```bash
-cd [directory] && gemini -p "
-PURPOSE: [planning goal from topic]
-TASK: Comprehensive planning and architecture analysis
+cd [dir] && gemini -p "
+PURPOSE: [goal]
+TASK: Architecture planning
 MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md [entire codebase in directory]
-EXPECTED: Strategic insights, implementation recommendations, key decisions
-RULES: $(cat ~/.claude/prompt-templates/plan.md) | Focus on [topic area]
+CONTEXT: @**/*
+EXPECTED: Modification plan, impact analysis
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt)
 "
+# Qwen: Replace 'gemini' with 'qwen'
 ```
 
-## Examples
-
-**Basic Planning Analysis (Standard Mode)**:
+**Codex** (planning + implementation guidance):
 ```bash
-/cli:mode:plan "design user dashboard architecture"
-# Executes: Gemini with planning template
-# Returns: Architecture recommendations, component design, roadmap
-```
-
-**Intelligent Planning (Agent Mode)**:
-```bash
-/cli:mode:plan --agent "design microservices architecture for payment system"
-# Phase 1: Classifies as architectural planning, keywords ['microservices', 'payment', 'architecture']
-# Phase 2: MCP discovers existing services, payment flows, integration patterns
-# Phase 3: Builds planning prompt with plan template + current architecture context
-# Phase 4: Executes Gemini with comprehensive project understanding
-# Phase 5: Saves planning document with implementation roadmap and migration strategy
-# Returns: Strategic architecture plan + implementation roadmap + risk assessment
-```
-
-**Standard Template Example**:
-```bash
-cd . && gemini -p "
-PURPOSE: Design user dashboard architecture
-TASK: Plan dashboard component structure and data flow
+codex -C [dir] --full-auto exec "
+PURPOSE: [goal]
+TASK: Architecture planning
 MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md
-EXPECTED: Architecture recommendations, component design, data flow diagram
-RULES: $(cat ~/.claude/prompt-templates/plan.md) | Focus on scalability
-"
+CONTEXT: @**/*
+EXPECTED: Plan, implementation roadmap
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt)
+" -m gpt-5 --skip-git-repo-check -s danger-full-access
 ```
 
-**Directory-Specific Planning**:
-```bash
-cd src/api && gemini -p "
-PURPOSE: Plan API refactoring strategy
-TASK: Analyze current API structure and recommend improvements
-MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md
-EXPECTED: Refactoring roadmap, breaking change analysis, migration plan
-RULES: $(cat ~/.claude/prompt-templates/plan.md) | Maintain backward compatibility
-"
-```
+## Output
 
-## Planning Workflow
-
-```bash
-# 1. Discover project structure
-~/.claude/scripts/get_modules_by_depth.sh
-find . -name "*.ts" -type f
-
-# 2. Gather existing architecture info
-rg "architecture|design" --files-with-matches
-
-# 3. Execute planning analysis (analysis only, no code changes)
-/cli:mode:plan "topic for strategic planning"
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND planning is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/plan-[timestamp].md`
-- **No active session OR exploratory planning**:
-  - Save to `.workflow/.scratchpad/plan-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-dashboard`, planning dashboard architecture → `.chat/plan-20250105-143022.md`
-- No session, exploring new feature idea → `.scratchpad/plan-feature-idea-20250105-143045.md`
+- **With session**: `.workflow/WFS-[id]/.chat/plan-[timestamp].md`
+- **No session**: `.workflow/.scratchpad/plan-[desc]-[timestamp].md`
 
 ## Notes
 
-- Command templates and file patterns: see intelligent-tools-strategy.md (loaded in memory)
-- Template path: `~/.claude/prompt-templates/plan.md`
-- Uses `@**/*` for in CONTEXT field for comprehensive project context
+- Template: `~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt`
+- See `intelligent-tools-strategy.md` for detailed tool usage

.claude/commands/enhance-prompt.md

@@ -1,6 +1,6 @@
 ---
 name: enhance-prompt
-description: Context-aware prompt enhancement using session memory and codebase analysis
+description: Enhanced prompt transformation using session memory and codebase analysis with --enhance flag detection
 argument-hint: "user input to enhance"
 ---
 

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

@@ -0,0 +1,182 @@
+---
+name: load-skill-memory
+description: Activate SKILL package (auto-detect from paths/keywords or manual) and intelligently load documentation based on task intent keywords
+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 **activates SKILL package** (auto-detect from task or manual specification) 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**:
+- **Flexible Activation**: Auto-detect skill from task description/paths, or user explicitly specifies
+- **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 or path mentions (system extracts skill name from file paths for intelligent triggering). Use this command only when manual activation is needed.
+
+## 2. Parameters
+
+- `[skill_name]` (Optional): Name of SKILL package to activate
+  - If omitted: System auto-detects from task description or file paths
+  - If specified: Direct activation of named SKILL package
+  - Example: `my_project`, `api_service`
+  - Must match directory name under `.claude/skills/`
+
+- `"task intent description"` (Required): Description of what you want to do
+  - Used for both: auto-detection (if skill_name omitted) and documentation scope selection
+  - **Analysis tasks**: "分析builder pattern实现", "理解参数系统架构"
+  - **Modification tasks**: "修改workflow逻辑", "增强thermal template功能"
+  - **Learning tasks**: "学习接口设计模式", "了解测试框架使用"
+  - **With paths**: "修改D:\projects\my_project\src\auth.py的认证逻辑" (auto-extracts `my_project`)
+
+## 3. Execution Flow
+
+### Step 1: Determine SKILL Name (if not provided)
+
+**Auto-Detection Strategy** (when skill_name parameter is omitted):
+1. **Path Extraction**: Scan task description for file paths
+   - Extract potential project names from path segments
+   - Example: `"修改D:\projects\my_project\src\auth.py"` → extracts `my_project`
+2. **Keyword Matching**: Match task keywords against SKILL descriptions
+   - Search for project-specific terms, domain keywords
+3. **Validation**: Check if extracted name matches `.claude/skills/{skill_name}/`
+
+**Result**: Either uses provided skill_name or auto-detected name for activation
+
+### Step 2: Activate SKILL and Analyze Intent
+
+**Activate SKILL Package**:
+```javascript
+Skill(command: "${skill_name}")  // Uses provided or auto-detected 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 3: 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 Examples
+
+### Example 1: Manual Specification
+
+**User Command**:
+```bash
+/memory:load-skill-memory my_project "修改认证模块增加OAuth支持"
+```
+
+**Execution**:
+```javascript
+// Step 1: Use provided skill_name
+skill_name = "my_project"  // Directly from parameter
+
+// Step 2: Activate SKILL
+Skill(command: "my_project")
+
+// Step 3: Intent Analysis
+Keywords: ["修改", "认证模块", "增加", "OAuth"]
+Action: modifying (implementation)
+Scope: auth module + examples
+
+// 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)
+```
+
+### Example 2: Auto-Detection from Path
+
+**User Command**:
+```bash
+/memory:load-skill-memory "修改D:\projects\my_project\src\services\api.py的接口逻辑"
+```
+
+**Execution**:
+```javascript
+// Step 1: Auto-detect skill_name from path
+Path detected: "D:\projects\my_project\src\services\api.py"
+Extracted: "my_project"
+Validated: .claude/skills/my_project/ exists ✓
+skill_name = "my_project"
+
+// Step 2: Activate SKILL
+Skill(command: "my_project")
+
+// Step 3: Intent Analysis
+Keywords: ["修改", "services", "接口逻辑"]
+Action: modifying (implementation)
+Scope: services module + examples
+
+// Load documentation based on intent
+Read(.workflow/docs/my_project/services/README.md)
+Read(.workflow/docs/my_project/services/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/load.md

@@ -1,6 +1,6 @@
 ---
 name: load
-description: Load project memory by delegating to agent, returns structured core content package for subsequent operations
+description: Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context
 argument-hint: "[--tool gemini|qwen] \"task context description\""
 allowed-tools: Task(*), Bash(*)
 examples:

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

@@ -0,0 +1,534 @@
+---
+name: skill-memory
+description: 4-phase autonomous orchestrator: check docs → /memory:docs planning → /workflow:execute → generate SKILL.md with progressive loading index (skips phases 2-3 if docs exist)
+argument-hint: "[path] [--tool <gemini|qwen|codex>] [--regenerate] [--mode <full|partial>] [--cli-execute]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Bash(*), Read(*), Write(*)
+---
+
+# Memory SKILL Package Generator
+
+## Orchestrator Role
+
+**Pure Orchestrator**: Execute documentation generation workflow, then generate SKILL.md index. Does NOT create task JSON files.
+
+**Auto-Continue Workflow**: This command runs **fully autonomously** once triggered. Each phase completes and automatically triggers the next phase without user interaction.
+
+**Execution Paths**:
+- **Full Path**: All 4 phases (no existing docs OR `--regenerate` specified)
+- **Skip Path**: Phase 1 → Phase 4 (existing docs found AND no `--regenerate` flag)
+- **Phase 4 Always Executes**: SKILL.md index is never skipped, always generated or updated
+
+## 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 (session_id, task_count, file paths)
+4. **Auto-Continue**: After completing each phase, update TodoWrite and immediately execute next phase
+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
+
+---
+
+## 4-Phase Execution
+
+### Phase 1: Prepare Arguments
+
+**Goal**: Parse command arguments and check existing documentation
+
+**Step 1: Get Target Path and Project Name**
+```bash
+# Get current directory (or use provided path)
+bash(pwd)
+
+# Get project name from directory
+bash(basename "$(pwd)")
+
+# Get project root
+bash(git rev-parse --show-toplevel 2>/dev/null || pwd)
+```
+
+**Output**:
+- `target_path`: `/d/my_project`
+- `project_name`: `my_project`
+- `project_root`: `/d/my_project`
+
+**Step 2: Set Default Parameters**
+```bash
+# Default values (use these unless user specifies otherwise):
+# - tool: "gemini"
+# - mode: "full"
+# - regenerate: false (no --regenerate flag)
+# - cli_execute: false (no --cli-execute flag)
+```
+
+**Step 3: Check Existing Documentation**
+```bash
+# Check if docs directory exists
+bash(test -d .workflow/docs/my_project && echo "exists" || echo "not_exists")
+
+# Count existing documentation files
+bash(find .workflow/docs/my_project -name "*.md" 2>/dev/null | wc -l || echo 0)
+```
+
+**Output**:
+- `docs_exists`: `exists` or `not_exists`
+- `existing_docs`: `5` (or `0` if no docs)
+
+**Step 4: Determine Execution Path**
+
+**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 Variables**:
+- `PROJECT_NAME`: `my_project`
+- `TARGET_PATH`: `/d/my_project`
+- `DOCS_PATH`: `.workflow/docs/my_project`
+- `TOOL`: `gemini` (default) or user-specified
+- `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`: Count of existing documentation files
+- `SKIP_DOCS_GENERATION`: `true` if skipping Phase 2/3, `false` otherwise
+
+**Completion & TodoWrite**:
+- If `SKIP_DOCS_GENERATION = true`: Mark phase 1 completed, phase 2&3 completed (skipped), phase 4 in_progress
+- If `SKIP_DOCS_GENERATION = false`: Mark phase 1 completed, phase 2 in_progress
+
+**Next Action**:
+- 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
+
+**Skip Condition**: This phase is **skipped if SKIP_DOCS_GENERATION = true** (documentation already exists without --regenerate flag)
+
+**Goal**: Trigger documentation generation workflow
+
+**Command**:
+```bash
+SlashCommand(command="/memory:docs [targetPath] --tool [tool] --mode [mode] [--cli-execute]")
+```
+
+**Example**:
+```bash
+/memory:docs /d/my_app --tool gemini --mode full
+/memory:docs /d/my_app --tool gemini --mode full --cli-execute
+```
+
+**Note**: The `--regenerate` flag is handled in Phase 1 by deleting existing documentation. This command always calls `/memory:docs` without the regenerate flag, relying on docs.md's built-in update detection.
+
+**Parse Output**:
+- Extract session ID: `WFS-docs-[timestamp]` (store as `docsSessionId`)
+- Extract task count (store as `taskCount`)
+
+**Completion Criteria**:
+- `/memory:docs` command executed successfully
+- Session ID extracted and stored
+- Task count retrieved
+- Task files created in `.workflow/[docsSessionId]/.task/`
+- workflow-session.json exists
+
+**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
+
+**Next Action**: Display docs planning results (session ID, task count) → Auto-continue to Phase 3
+
+---
+
+### Phase 3: Execute Documentation Generation
+
+**Skip Condition**: This phase is **skipped if SKIP_DOCS_GENERATION = true** (documentation already exists without --regenerate flag)
+
+**Goal**: Execute documentation generation tasks
+
+**Command**:
+```bash
+SlashCommand(command="/workflow:execute")
+```
+
+**Note**: `/workflow:execute` automatically discovers active session from Phase 2
+
+**Completion Criteria**:
+- `/workflow:execute` command executed successfully
+- Documentation files generated in `.workflow/docs/[projectName]/`
+- 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
+
+**Next Action**: Display execution results (file count, module count) → Auto-continue to Phase 4
+
+---
+
+### Phase 4: Generate SKILL.md Index
+
+**Note**: This phase is **NEVER skipped** - it always executes to generate or update the SKILL index.
+
+**Step 1: Read Key Files** (Use Read tool)
+- `.workflow/docs/{project_name}/README.md` (required)
+- `.workflow/docs/{project_name}/ARCHITECTURE.md` (optional)
+
+**Step 2: Discover Structure**
+```bash
+bash(find .workflow/docs/{project_name} -name "*.md" | sed 's|.workflow/docs/{project_name}/||' | awk -F'/' '{if(NF>=2) print $1"/"$2}' | sort -u)
+```
+
+**Step 3: Generate Intelligent Description**
+
+Extract from README + structure: Function (capabilities), Modules (names), Keywords (API/CLI/auth/etc.)
+
+**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.`
+
+**Key Elements**:
+- **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")
+- **Trigger Optimization**: Include project path, emphasize "especially when no relevant context exists in memory"
+- **Action Coverage**: 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
+bash(mkdir -p .claude/skills/{project_name})
+```
+
+`.claude/skills/{project_name}/SKILL.md`:
+```yaml
+---
+name: {project_name}
+description: {intelligent description from Step 3}
+version: 1.0.0
+---
+# {Project Name} SKILL Package
+
+## Documentation: `../../../.workflow/docs/{project_name}/`
+
+## Progressive Loading
+### Level 0: Quick Start (~2K)
+- [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)
+### Level 3: Deep Dive (~40K)
+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
+
+**Final Action**: Report completion summary to user
+
+**Return to User**:
+```
+SKILL Package Generation Complete
+
+Project: {project_name}
+Documentation: .workflow/docs/{project_name}/ ({doc_count} files)
+SKILL Index: .claude/skills/{project_name}/SKILL.md
+
+Generated:
+- {task_count} documentation tasks completed
+- SKILL.md with progressive loading (4 levels)
+- Module index with {module_count} modules
+
+Usage:
+- Load Level 0: Quick project overview (~2K tokens)
+- Load Level 1: Core modules (~8K tokens)
+- Load Level 2: Complete docs (~25K tokens)
+- Load Level 3: Everything (~40K tokens)
+```
+
+---
+
+## Implementation Details
+
+### Critical 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
+   ```
+
+### TodoWrite Patterns
+
+#### Initialization (Before Phase 1)
+
+**FIRST ACTION**: Create TodoList with all 4 phases
+```javascript
+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
+
+#### Full Path (SKIP_DOCS_GENERATION = false)
+
+**After Phase 1**:
+```javascript
+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"}
+]})
+// Auto-continue to Phase 2
+```
+
+**After Phase 2**:
+```javascript
+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"}
+]})
+// Auto-continue to Phase 3
+```
+
+**After Phase 3**:
+```javascript
+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"}
+]})
+// Auto-continue to Phase 4
+```
+
+**After Phase 4**:
+```javascript
+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"}
+]})
+// Report completion summary to user
+```
+
+#### Skip Path (SKIP_DOCS_GENERATION = true)
+
+**After Phase 1** (detects existing docs, skips Phase 2 & 3):
+```javascript
+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."
+// Jump directly to Phase 4
+```
+
+**After Phase 4**:
+```javascript
+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"}
+]})
+// Report completion summary to user
+```
+
+### Execution Flow Diagrams
+
+#### Full Path Flow
+```
+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 Flow
+```
+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
+```
+
+### 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
+/memory:skill-memory [path] [--tool <gemini|qwen|codex>] [--regenerate] [--mode <full|partial>] [--cli-execute]
+```
+
+- **path**: Target directory (default: current directory)
+- **--tool**: CLI tool for documentation (default: gemini)
+  - `gemini`: Comprehensive documentation
+  - `qwen`: Architecture analysis
+  - `codex`: Implementation validation
+- **--regenerate**: Force regenerate all documentation
+  - When enabled: Deletes existing `.workflow/docs/{project_name}/` before regeneration
+  - Ensures fresh documentation from source code
+- **--mode**: Documentation mode (default: full)
+  - `full`: Complete docs (modules + README + ARCHITECTURE + EXAMPLES)
+  - `partial`: Module docs only
+- **--cli-execute**: Enable CLI-based documentation generation (optional)
+  - When enabled: CLI generates docs directly in implementation_approach
+  - When disabled (default): Agent generates documentation content
+
+---
+
+## Examples
+
+### Example 1: Generate SKILL Package (Default)
+
+```bash
+/memory:skill-memory
+```
+
+**Workflow**:
+1. Phase 1: Detects current directory, checks existing docs
+2. Phase 2: Calls `/memory:docs . --tool gemini --mode full` (Agent Mode)
+3. Phase 3: Executes documentation generation via `/workflow:execute`
+4. Phase 4: Generates SKILL.md at `.claude/skills/{project_name}/SKILL.md`
+
+### Example 2: Regenerate with Qwen
+
+```bash
+/memory:skill-memory /d/my_app --tool qwen --regenerate
+```
+
+**Workflow**:
+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
+
+### Example 3: Partial Mode (Modules Only)
+
+```bash
+/memory:skill-memory --mode partial
+```
+
+**Workflow**:
+1. Phase 1: Detects partial mode
+2. Phase 2: Calls `/memory:docs . --tool gemini --mode partial` (Agent Mode)
+3. Phase 3: Executes module documentation only
+4. Phase 4: Generates SKILL.md with module-only index
+
+### Example 4: CLI Execute Mode
+
+```bash
+/memory:skill-memory --cli-execute
+```
+
+**Workflow**:
+1. Phase 1: Detects CLI execute mode
+2. Phase 2: Calls `/memory:docs . --tool gemini --mode full --cli-execute` (CLI Mode)
+3. Phase 3: Executes CLI-based documentation generation
+4. Phase 4: Generates SKILL.md at `.claude/skills/{project_name}/SKILL.md`
+
+### Example 5: Skip Path (Existing Docs)
+
+```bash
+/memory:skill-memory
+```
+
+**Scenario**: Documentation already exists in `.workflow/docs/{project_name}/`
+
+**Workflow**:
+1. Phase 1: Detects existing docs (5 files), sets SKIP_DOCS_GENERATION = true
+2. Display: "Documentation already exists, skipping Phase 2 and Phase 3. Use --regenerate to force regeneration."
+3. Phase 4: Generates or updates SKILL.md index only (~5-10x faster)
+
+---
+
+## Benefits
+
+- **Pure Orchestrator**: No task JSON generation, delegates to /memory:docs
+- **Auto-Continue**: Autonomous 4-phase execution without user interaction
+- **Intelligent Skip**: Detects existing docs and skips regeneration for fast SKILL updates
+- **Always Fresh Index**: Phase 4 always executes to ensure SKILL.md stays synchronized
+- **Simplified**: ~70% less code than previous version
+- **Maintainable**: Changes to /memory:docs automatically apply
+- **Direct Generation**: Phase 4 directly writes SKILL.md
+- **Flexible**: Supports all /memory:docs options (tool, mode, cli-execute)
+
+## Architecture
+
+```
+skill-memory (orchestrator)
+  ├─ Phase 1: Prepare (bash commands, skip decision)
+  ├─ Phase 2: /memory:docs (task planning, skippable)
+  ├─ Phase 3: /workflow:execute (task execution, skippable)
+  └─ Phase 4: Write SKILL.md (direct file generation, always runs)
+
+No task JSON created by this command
+All documentation tasks managed by /memory:docs
+Smart skip logic: 5-10x faster when docs exist
+```

.claude/commands/memory/tech-research.md

@@ -0,0 +1,477 @@
+---
+name: tech-research
+description: 3-phase orchestrator: extract tech stack from session/name → delegate to agent for Exa research and module generation → generate SKILL.md index (skips phase 2 if exists)
+argument-hint: "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Bash(*), Read(*), Write(*), Task(*)
+---
+
+# Tech Stack Research SKILL Generator
+
+## Overview
+
+**Pure Orchestrator with Agent Delegation**: Prepares context paths and delegates ALL work to agent. Agent produces files directly.
+
+**Auto-Continue Workflow**: Runs fully autonomously once triggered. Each phase completes and automatically triggers the next phase.
+
+**Execution Paths**:
+- **Full Path**: All 3 phases (no existing SKILL OR `--regenerate` specified)
+- **Skip Path**: Phase 1 → Phase 3 (existing SKILL found AND no `--regenerate` flag)
+- **Phase 3 Always Executes**: SKILL index is always generated or updated
+
+**Agent Responsibility**:
+- Agent does ALL the work: context reading, Exa research, content synthesis, file writing
+- Orchestrator only provides context paths and waits for completion
+
+## Core Rules
+
+1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 execution
+2. **Context Path Delegation**: Pass session directory or tech stack name to agent, let agent do discovery
+3. **Agent Produces Files**: Agent directly writes all module files, orchestrator does NOT parse agent output
+4. **Auto-Continue**: After completing each phase, update TodoWrite and immediately execute next phase
+5. **No User Prompts**: Never ask user questions or wait for input between phases
+6. **Track Progress**: Update TodoWrite after EVERY phase completion before starting next phase
+7. **Lightweight Index**: Phase 3 only generates SKILL.md index by reading existing files
+
+---
+
+## 3-Phase Execution
+
+### Phase 1: Prepare Context Paths
+
+**Goal**: Detect input mode, prepare context paths for agent, check existing SKILL
+
+**Input Mode Detection**:
+```bash
+# Get input parameter
+input="$1"
+
+# Detect mode
+if [[ "$input" == WFS-* ]]; then
+  MODE="session"
+  SESSION_ID="$input"
+  CONTEXT_PATH=".workflow/${SESSION_ID}"
+else
+  MODE="direct"
+  TECH_STACK_NAME="$input"
+  CONTEXT_PATH="$input"  # Pass tech stack name as context
+fi
+```
+
+**Check Existing SKILL**:
+```bash
+# For session mode, peek at session to get tech stack name
+if [[ "$MODE" == "session" ]]; then
+  bash(test -f ".workflow/${SESSION_ID}/workflow-session.json")
+  Read(.workflow/${SESSION_ID}/workflow-session.json)
+  # Extract tech_stack_name (minimal extraction)
+fi
+
+# Normalize and check
+normalized_name=$(echo "$TECH_STACK_NAME" | tr '[:upper:]' '[:lower:]' | tr ' ' '-')
+bash(test -d ".claude/skills/${normalized_name}" && echo "exists" || echo "not_exists")
+bash(find ".claude/skills/${normalized_name}" -name "*.md" 2>/dev/null | wc -l || echo 0)
+```
+
+**Skip Decision**:
+```javascript
+if (existing_files > 0 && !regenerate_flag) {
+  SKIP_GENERATION = true
+  message = "Tech stack SKILL already exists, skipping Phase 2. Use --regenerate to force regeneration."
+} else if (regenerate_flag) {
+  bash(rm -rf ".claude/skills/${normalized_name}")
+  SKIP_GENERATION = false
+  message = "Regenerating tech stack SKILL from scratch."
+} else {
+  SKIP_GENERATION = false
+  message = "No existing SKILL found, generating new tech stack documentation."
+}
+```
+
+**Output Variables**:
+- `MODE`: `session` or `direct`
+- `SESSION_ID`: Session ID (if session mode)
+- `CONTEXT_PATH`: Path to session directory OR tech stack name
+- `TECH_STACK_NAME`: Extracted or provided tech stack name
+- `SKIP_GENERATION`: Boolean - whether to skip Phase 2
+
+**TodoWrite**:
+- If skipping: Mark phase 1 completed, phase 2 completed, phase 3 in_progress
+- If not skipping: Mark phase 1 completed, phase 2 in_progress
+
+---
+
+### Phase 2: Agent Produces All Files
+
+**Skip Condition**: Skipped if `SKIP_GENERATION = true`
+
+**Goal**: Delegate EVERYTHING to agent - context reading, Exa research, content synthesis, and file writing
+
+**Agent Task Specification**:
+
+```
+Task(
+  subagent_type: "general-purpose",
+  description: "Generate tech stack SKILL: {CONTEXT_PATH}",
+  prompt: "
+Generate a complete tech stack SKILL package with Exa research.
+
+**Context Provided**:
+- Mode: {MODE}
+- Context Path: {CONTEXT_PATH}
+
+**Templates Available**:
+- Module Format: ~/.claude/workflows/cli-templates/prompts/tech/tech-module-format.txt
+- SKILL Index: ~/.claude/workflows/cli-templates/prompts/tech/tech-skill-index.txt
+
+**Your Responsibilities**:
+
+1. **Extract Tech Stack Information**:
+
+   IF MODE == 'session':
+     - Read `.workflow/{SESSION_ID}/workflow-session.json`
+     - Read `.workflow/{SESSION_ID}/.process/context-package.json`
+     - Extract tech_stack: {language, frameworks, libraries}
+     - Build tech stack name: \"{language}-{framework1}-{framework2}\"
+     - Example: \"typescript-react-nextjs\"
+
+   IF MODE == 'direct':
+     - Tech stack name = CONTEXT_PATH
+     - Parse composite: split by '-' delimiter
+     - Example: \"typescript-react-nextjs\" → [\"typescript\", \"react\", \"nextjs\"]
+
+2. **Execute Exa Research** (4-6 parallel queries):
+
+   Base Queries (always execute):
+   - mcp__exa__get_code_context_exa(query: \"{tech} core principles best practices 2025\", tokensNum: 8000)
+   - mcp__exa__get_code_context_exa(query: \"{tech} common patterns architecture examples\", tokensNum: 7000)
+   - mcp__exa__web_search_exa(query: \"{tech} configuration setup tooling 2025\", numResults: 5)
+   - mcp__exa__get_code_context_exa(query: \"{tech} testing strategies\", tokensNum: 5000)
+
+   Component Queries (if composite):
+   - For each additional component:
+     mcp__exa__get_code_context_exa(query: \"{main_tech} {component} integration\", tokensNum: 5000)
+
+3. **Read Module Format Template**:
+
+   Read template for structure guidance:
+   ```bash
+   Read(~/.claude/workflows/cli-templates/prompts/tech/tech-module-format.txt)
+   ```
+
+4. **Synthesize Content into 6 Modules**:
+
+   Follow template structure from tech-module-format.txt:
+   - **principles.md** - Core concepts, philosophies (~3K tokens)
+   - **patterns.md** - Implementation patterns with code examples (~5K tokens)
+   - **practices.md** - Best practices, anti-patterns, pitfalls (~4K tokens)
+   - **testing.md** - Testing strategies, frameworks (~3K tokens)
+   - **config.md** - Setup, configuration, tooling (~3K tokens)
+   - **frameworks.md** - Framework integration (only if composite, ~4K tokens)
+
+   Each module follows template format:
+   - Frontmatter (YAML)
+   - Main sections with clear headings
+   - Code examples from Exa research
+   - Best practices sections
+   - References to Exa sources
+
+5. **Write Files Directly**:
+
+   ```javascript
+   // Create directory
+   bash(mkdir -p \".claude/skills/{tech_stack_name}\")
+
+   // Write each module file using Write tool
+   Write({ file_path: \".claude/skills/{tech_stack_name}/principles.md\", content: ... })
+   Write({ file_path: \".claude/skills/{tech_stack_name}/patterns.md\", content: ... })
+   Write({ file_path: \".claude/skills/{tech_stack_name}/practices.md\", content: ... })
+   Write({ file_path: \".claude/skills/{tech_stack_name}/testing.md\", content: ... })
+   Write({ file_path: \".claude/skills/{tech_stack_name}/config.md\", content: ... })
+   // Write frameworks.md only if composite
+
+   // Write metadata.json
+   Write({
+     file_path: \".claude/skills/{tech_stack_name}/metadata.json\",
+     content: JSON.stringify({
+       tech_stack_name,
+       components,
+       is_composite,
+       generated_at: timestamp,
+       source: \"exa-research\",
+       research_summary: { total_queries, total_sources }
+     })
+   })
+   ```
+
+6. **Report Completion**:
+
+   Provide summary:
+   - Tech stack name
+   - Files created (count)
+   - Exa queries executed
+   - Sources consulted
+
+**CRITICAL**:
+- MUST read external template files before generating content (step 3 for modules, step 4 for index)
+- You have FULL autonomy - read files, execute Exa, synthesize content, write files
+- Do NOT return JSON or structured data - produce actual .md files
+- Handle errors gracefully (Exa failures, missing files, template read failures)
+- If tech stack cannot be determined, ask orchestrator to clarify
+  "
+)
+```
+
+**Completion Criteria**:
+- Agent task executed successfully
+- 5-6 modular files written to `.claude/skills/{tech_stack_name}/`
+- metadata.json written
+- Agent reports completion
+
+**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
+
+---
+
+### Phase 3: Generate SKILL.md Index
+
+**Note**: This phase **ALWAYS executes** - generates or updates the SKILL index.
+
+**Goal**: Read generated module files and create SKILL.md index with loading recommendations
+
+**Steps**:
+
+1. **Verify Generated Files**:
+   ```bash
+   bash(find ".claude/skills/${TECH_STACK_NAME}" -name "*.md" -type f | sort)
+   ```
+
+2. **Read metadata.json**:
+   ```javascript
+   Read(.claude/skills/${TECH_STACK_NAME}/metadata.json)
+   // Extract: tech_stack_name, components, is_composite, research_summary
+   ```
+
+3. **Read Module Headers** (optional, first 20 lines):
+   ```javascript
+   Read(.claude/skills/${TECH_STACK_NAME}/principles.md, limit: 20)
+   // Repeat for other modules
+   ```
+
+4. **Read SKILL Index Template**:
+
+   ```javascript
+   Read(~/.claude/workflows/cli-templates/prompts/tech/tech-skill-index.txt)
+   ```
+
+5. **Generate SKILL.md Index**:
+
+   Follow template from tech-skill-index.txt with variable substitutions:
+   - `{TECH_STACK_NAME}`: From metadata.json
+   - `{MAIN_TECH}`: Primary technology
+   - `{ISO_TIMESTAMP}`: Current timestamp
+   - `{QUERY_COUNT}`: From research_summary
+   - `{SOURCE_COUNT}`: From research_summary
+   - Conditional sections for composite tech stacks
+
+   Template provides structure for:
+   - Frontmatter with metadata
+   - Overview and tech stack description
+   - Module organization (Core/Practical/Config sections)
+   - Loading recommendations (Quick/Implementation/Complete)
+   - Usage guidelines and auto-trigger keywords
+   - Research metadata and version history
+
+6. **Write SKILL.md**:
+   ```javascript
+   Write({
+     file_path: `.claude/skills/${TECH_STACK_NAME}/SKILL.md`,
+     content: generatedIndexMarkdown
+   })
+   ```
+
+**Completion Criteria**:
+- SKILL.md index written
+- All module files verified
+- Loading recommendations included
+
+**TodoWrite**: Mark phase 3 completed
+
+**Final Report**:
+```
+Tech Stack SKILL Package Complete
+
+Tech Stack: {TECH_STACK_NAME}
+Location: .claude/skills/{TECH_STACK_NAME}/
+
+Files: SKILL.md + 5-6 modules + metadata.json
+Exa Research: {queries} queries, {sources} sources
+
+Usage: Skill(command: "{TECH_STACK_NAME}")
+```
+
+---
+
+## Implementation Details
+
+### TodoWrite Patterns
+
+**Initialization** (Before Phase 1):
+```javascript
+TodoWrite({todos: [
+  {"content": "Prepare context paths", "status": "in_progress", "activeForm": "Preparing context paths"},
+  {"content": "Agent produces all module files", "status": "pending", "activeForm": "Agent producing files"},
+  {"content": "Generate SKILL.md index", "status": "pending", "activeForm": "Generating SKILL index"}
+]})
+```
+
+**Full Path** (SKIP_GENERATION = false):
+```javascript
+// After Phase 1
+TodoWrite({todos: [
+  {"content": "Prepare context paths", "status": "completed", ...},
+  {"content": "Agent produces all module files", "status": "in_progress", ...},
+  {"content": "Generate SKILL.md index", "status": "pending", ...}
+]})
+
+// After Phase 2
+TodoWrite({todos: [
+  {"content": "Prepare context paths", "status": "completed", ...},
+  {"content": "Agent produces all module files", "status": "completed", ...},
+  {"content": "Generate SKILL.md index", "status": "in_progress", ...}
+]})
+
+// After Phase 3
+TodoWrite({todos: [
+  {"content": "Prepare context paths", "status": "completed", ...},
+  {"content": "Agent produces all module files", "status": "completed", ...},
+  {"content": "Generate SKILL.md index", "status": "completed", ...}
+]})
+```
+
+**Skip Path** (SKIP_GENERATION = true):
+```javascript
+// After Phase 1 (skip Phase 2)
+TodoWrite({todos: [
+  {"content": "Prepare context paths", "status": "completed", ...},
+  {"content": "Agent produces all module files", "status": "completed", ...},  // Skipped
+  {"content": "Generate SKILL.md index", "status": "in_progress", ...}
+]})
+```
+
+### Execution Flow
+
+**Full Path**:
+```
+User → TodoWrite Init → Phase 1 (prepare) → Phase 2 (agent writes files) → Phase 3 (write index) → Report
+```
+
+**Skip Path**:
+```
+User → TodoWrite Init → Phase 1 (detect existing) → Phase 3 (update index) → Report
+```
+
+### Error Handling
+
+**Phase 1 Errors**:
+- Invalid session ID: Report error, verify session exists
+- Missing context-package: Warn, fall back to direct mode
+- No tech stack detected: Ask user to specify tech stack name
+
+**Phase 2 Errors (Agent)**:
+- Agent task fails: Retry once, report if fails again
+- Exa API failures: Agent handles internally with retries
+- Incomplete results: Warn user, proceed with partial data if minimum sections available
+
+**Phase 3 Errors**:
+- Write failures: Report which files failed
+- Missing files: Note in SKILL.md, suggest regeneration
+
+---
+
+## Parameters
+
+```bash
+/memory:tech-research [session-id | "tech-stack-name"] [--regenerate] [--tool <gemini|qwen>]
+```
+
+**Arguments**:
+- **session-id | tech-stack-name**: Input source (auto-detected by WFS- prefix)
+  - Session mode: `WFS-user-auth-v2` - Extract tech stack from workflow
+  - Direct mode: `"typescript"`, `"typescript-react-nextjs"` - User specifies
+- **--regenerate**: Force regenerate existing SKILL (deletes and recreates)
+- **--tool**: Reserved for future CLI integration (default: gemini)
+
+---
+
+## Examples
+
+**Generated File Structure** (for all examples):
+```
+.claude/skills/{tech-stack}/
+├── SKILL.md           # Index (Phase 3)
+├── principles.md      # Agent (Phase 2)
+├── patterns.md        # Agent
+├── practices.md       # Agent
+├── testing.md         # Agent
+├── config.md          # Agent
+├── frameworks.md      # Agent (if composite)
+└── metadata.json      # Agent
+```
+
+### Direct Mode - Single Stack
+
+```bash
+/memory:tech-research "typescript"
+```
+
+**Workflow**:
+1. Phase 1: Detects direct mode, checks existing SKILL
+2. Phase 2: Agent executes 4 Exa queries, writes 5 modules
+3. Phase 3: Generates SKILL.md index
+
+### Direct Mode - Composite Stack
+
+```bash
+/memory:tech-research "typescript-react-nextjs"
+```
+
+**Workflow**:
+1. Phase 1: Decomposes into ["typescript", "react", "nextjs"]
+2. Phase 2: Agent executes 6 Exa queries (4 base + 2 components), writes 6 modules (adds frameworks.md)
+3. Phase 3: Generates SKILL.md index with framework integration
+
+### Session Mode - Extract from Workflow
+
+```bash
+/memory:tech-research WFS-user-auth-20251104
+```
+
+**Workflow**:
+1. Phase 1: Reads session, extracts tech stack: `python-fastapi-sqlalchemy`
+2. Phase 2: Agent researches Python + FastAPI + SQLAlchemy, writes 6 modules
+3. Phase 3: Generates SKILL.md index
+
+### Regenerate Existing
+
+```bash
+/memory:tech-research "react" --regenerate
+```
+
+**Workflow**:
+1. Phase 1: Deletes existing SKILL due to --regenerate
+2. Phase 2: Agent executes fresh Exa research (latest 2025 practices)
+3. Phase 3: Generates updated SKILL.md
+
+### Skip Path - Fast Update
+
+```bash
+/memory:tech-research "python"
+```
+
+**Scenario**: SKILL already exists with 7 files
+
+**Workflow**:
+1. Phase 1: Detects existing SKILL, sets SKIP_GENERATION = true
+2. Phase 2: **SKIPPED**
+3. Phase 3: Updates SKILL.md index only (5-10x faster)
+
+

.claude/commands/memory/update-full.md

@@ -1,6 +1,6 @@
 ---
 name: update-full
-description: Complete project-wide CLAUDE.md documentation update with agent-based parallel execution and tool fallback
+description: Update all CLAUDE.md files using layer-based execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel
 argument-hint: "[--tool gemini|qwen|codex] [--path <directory>]"
 ---
 

.claude/commands/memory/update-related.md

@@ -1,6 +1,6 @@
 ---
 name: update-related
-description: Context-aware CLAUDE.md documentation updates based on recent changes with agent-based execution and tool fallback
+description: Update CLAUDE.md for git-changed modules using batched agent execution (4 modules/agent) with gemini→qwen→codex fallback, <15 modules uses direct execution
 argument-hint: "[--tool gemini|qwen|codex]"
 ---
 

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

@@ -0,0 +1,517 @@
+---
+name: workflow-skill-memory
+description: Process WFS-* archived sessions using universal-executor agents with Gemini analysis to generate workflow-progress SKILL package (sessions-timeline, lessons, conflicts)
+argument-hint: "session <session-id> | all"
+allowed-tools: Task(*), TodoWrite(*), Bash(*), Read(*), Write(*)
+---
+
+# Workflow SKILL Memory Generator
+
+## Overview
+
+Generate SKILL package from archived workflow sessions using agent-driven analysis. Supports single-session incremental updates or parallel processing of all sessions.
+
+**Scope**: Only processes WFS-* workflow sessions. Other session types (e.g., doc sessions) are automatically ignored.
+
+## Usage
+
+```bash
+/memory:workflow-skill-memory session WFS-<session-id>   # Process single WFS session
+/memory:workflow-skill-memory all                        # Process all WFS sessions in parallel
+```
+
+## Execution Modes
+
+### Mode 1: Single Session (`session <session-id>`)
+
+**Purpose**: Incremental update - process one archived session and merge into existing SKILL package
+
+**Workflow**:
+1. **Validate session**: Check if session exists in `.workflow/.archives/{session-id}/`
+2. **Invoke agent**: Call `universal-executor` to analyze session and update SKILL documents
+3. **Agent tasks**:
+   - Read session data from `.workflow/.archives/{session-id}/`
+   - Extract lessons, conflicts, and outcomes
+   - Use Gemini for intelligent aggregation (optional)
+   - Update or create SKILL documents using templates
+   - Regenerate SKILL.md index
+
+**Command Example**:
+```bash
+/memory:workflow-skill-memory session WFS-user-auth
+```
+
+**Expected Output**:
+```
+Session WFS-user-auth processed
+Updated:
+- sessions-timeline.md (1 session added)
+- lessons-learned.md (3 lessons merged)
+- conflict-patterns.md (1 conflict added)
+- SKILL.md (index regenerated)
+```
+
+---
+
+### Mode 2: All Sessions (`all`)
+
+**Purpose**: Full regeneration - process all archived sessions in parallel for complete SKILL package
+
+**Workflow**:
+1. **List sessions**: Read manifest.json to get all archived session IDs
+2. **Parallel invocation**: Launch multiple `universal-executor` agents in parallel (one per session)
+3. **Agent coordination**:
+   - Each agent processes one session independently
+   - Agents use Gemini for analysis
+   - Agents collect data into JSON (no direct file writes)
+   - Final aggregator agent merges results and generates SKILL documents
+
+**Command Example**:
+```bash
+/memory:workflow-skill-memory all
+```
+
+**Expected Output**:
+```
+All sessions processed in parallel
+Sessions: 8 total
+Updated:
+- sessions-timeline.md (8 sessions)
+- lessons-learned.md (24 lessons aggregated)
+- conflict-patterns.md (12 conflicts documented)
+- SKILL.md (index regenerated)
+```
+
+---
+
+## Implementation Flow
+
+### Phase 1: Validation and Setup
+
+**Step 1.1: Parse Command Arguments**
+
+Extract mode and session ID:
+```javascript
+if (args === "all") {
+  mode = "all"
+} else if (args.startsWith("session ")) {
+  mode = "session"
+  session_id = args.replace("session ", "").trim()
+} else {
+  ERROR = "Invalid arguments. Usage: session <session-id> | all"
+  EXIT
+}
+```
+
+**Step 1.2: Validate Archive Directory**
+```bash
+bash(test -d .workflow/.archives && echo "exists" || echo "missing")
+```
+
+If missing, report error and exit.
+
+**Step 1.3: Mode-Specific Validation**
+
+**Single Session Mode**:
+```bash
+# Validate session ID format (must start with WFS-)
+if [[ ! "$session_id" =~ ^WFS- ]]; then
+  ERROR = "Invalid session ID format. Only WFS-* sessions are supported"
+  EXIT
+fi
+
+# Check if session exists
+bash(test -d .workflow/.archives/{session_id} && echo "exists" || echo "missing")
+```
+
+If missing, report error: "Session {session_id} not found in archives"
+
+**All Sessions Mode**:
+```bash
+# Read manifest and filter only WFS- sessions
+bash(cat .workflow/.archives/manifest.json | jq -r '.archives[].session_id | select(startswith("WFS-"))')
+```
+
+Store filtered session IDs in array. Ignore doc sessions and other non-WFS sessions.
+
+**Step 1.4: TodoWrite Initialization**
+
+**Single Session Mode**:
+```javascript
+TodoWrite({todos: [
+  {"content": "Validate session existence", "status": "completed", "activeForm": "Validating session"},
+  {"content": "Invoke agent to process session", "status": "in_progress", "activeForm": "Invoking agent"},
+  {"content": "Verify SKILL package updated", "status": "pending", "activeForm": "Verifying update"}
+]})
+```
+
+**All Sessions Mode**:
+```javascript
+TodoWrite({todos: [
+  {"content": "Read manifest and list sessions", "status": "completed", "activeForm": "Reading manifest"},
+  {"content": "Invoke agents in parallel", "status": "in_progress", "activeForm": "Invoking agents"},
+  {"content": "Verify SKILL package regenerated", "status": "pending", "activeForm": "Verifying regeneration"}
+]})
+```
+
+---
+
+### Phase 2: Agent Invocation
+
+#### Single Session Mode - Agent Task
+
+Invoke `universal-executor` with session-specific task:
+
+**Agent Prompt Structure**:
+```
+Task: Process Workflow Session for SKILL Package
+
+Context:
+- Session ID: {session_id}
+- Session Path: .workflow/.archives/{session_id}/
+- Mode: Incremental update
+
+Objectives:
+
+1. Read session data:
+   - workflow-session.json (metadata)
+   - IMPL_PLAN.md (implementation summary)
+   - TODO_LIST.md (if exists)
+   - manifest.json entry for lessons
+
+2. Extract key information:
+   - Description, tags, metrics
+   - Lessons (successes, challenges, watch_patterns)
+   - Context package path (reference only)
+   - Key outcomes from IMPL_PLAN
+
+3. Use Gemini for aggregation (optional):
+   Command pattern:
+   cd .workflow/.archives/{session_id} && gemini -p "
+   PURPOSE: Extract lessons and conflicts from workflow session
+   TASK:
+   • Analyze IMPL_PLAN and lessons from manifest
+   • Identify success patterns and challenges
+   • Extract conflict patterns with resolutions
+   • Categorize by functional domain
+   MODE: analysis
+   CONTEXT: @IMPL_PLAN.md @workflow-session.json
+   EXPECTED: Structured lessons and conflicts in JSON format
+   RULES: Template reference from skill-aggregation.txt
+   "
+
+3.5. **Generate SKILL.md Description** (CRITICAL for auto-loading):
+
+   Read skill-index.txt template Section: "Description Field Generation"
+
+   Execute command to get project root:
+   ```bash
+   git rev-parse --show-toplevel  # Example output: /d/Claude_dms3
+   ```
+
+   Apply description format:
+   ```
+   Progressive workflow development history (located at {project_root}).
+   Load this SKILL when continuing development, analyzing past implementations,
+   or learning from workflow history, especially when no relevant context exists in memory.
+   ```
+
+   **Validation**:
+   - [ ] Path uses forward slashes (not backslashes)
+   - [ ] All three use cases present
+   - [ ] Trigger optimization phrase included
+   - [ ] Path is absolute (starts with / or drive letter)
+
+4. Read templates for formatting guidance:
+   - ~/.claude/workflows/cli-templates/prompts/workflow/skill-sessions-timeline.txt
+   - ~/.claude/workflows/cli-templates/prompts/workflow/skill-lessons-learned.txt
+   - ~/.claude/workflows/cli-templates/prompts/workflow/skill-conflict-patterns.txt
+   - ~/.claude/workflows/cli-templates/prompts/workflow/skill-index.txt
+
+   **CRITICAL**: From skill-index.txt, read these sections:
+   - "Description Field Generation" - Rules for generating description
+   - "Variable Substitution Guide" - All required variables
+   - "Generation Instructions" - Step-by-step generation process
+   - "Validation Checklist" - Final validation steps
+
+5. Update SKILL documents:
+   - sessions-timeline.md: Append new session, update domain grouping
+   - lessons-learned.md: Merge lessons into categories, update frequencies
+   - conflict-patterns.md: Add conflicts, update recurring pattern frequencies
+   - SKILL.md: Regenerate index with updated counts
+
+   **For SKILL.md generation**:
+   - Follow "Generation Instructions" from skill-index.txt (Steps 1-7)
+   - Use git command for project_root: `git rev-parse --show-toplevel`
+   - Apply "Description Field Generation" rules
+   - Validate using "Validation Checklist"
+   - Increment version (patch level)
+
+6. Return result JSON:
+   {
+     "status": "success",
+     "session_id": "{session_id}",
+     "updates": {
+       "sessions_added": 1,
+       "lessons_merged": count,
+       "conflicts_added": count
+     }
+   }
+```
+
+---
+
+#### All Sessions Mode - Parallel Agent Tasks
+
+**Step 2.1: Launch parallel session analyzers**
+
+Invoke multiple agents in parallel (one message with multiple Task calls):
+
+**Per-Session Agent Prompt**:
+```
+Task: Extract Session Data for SKILL Package
+
+Context:
+- Session ID: {session_id}
+- Mode: Parallel analysis (no direct file writes)
+
+Objectives:
+
+1. Read session data (same as single mode)
+
+2. Extract key information (same as single mode)
+
+3. Use Gemini for analysis (same as single mode)
+
+4. Return structured data JSON:
+   {
+     "status": "success",
+     "session_id": "{session_id}",
+     "data": {
+       "metadata": {
+         "description": "...",
+         "archived_at": "...",
+         "tags": [...],
+         "metrics": {...}
+       },
+       "lessons": {
+         "successes": [...],
+         "challenges": [...],
+         "watch_patterns": [...]
+       },
+       "conflicts": [
+         {
+           "type": "architecture|dependencies|testing|performance",
+           "pattern": "...",
+           "resolution": "...",
+           "code_impact": [...]
+         }
+       ],
+       "impl_summary": "First 200 chars of IMPL_PLAN",
+       "context_package_path": "..."
+     }
+   }
+```
+
+**Step 2.2: Aggregate results**
+
+After all session agents complete, invoke aggregator agent:
+
+**Aggregator Agent Prompt**:
+```
+Task: Aggregate Session Results and Generate SKILL Package
+
+Context:
+- Mode: Full regeneration
+- Input: JSON results from {session_count} session agents
+
+Objectives:
+
+1. Aggregate all session data:
+   - Collect metadata from all sessions
+   - Merge lessons by category
+   - Group conflicts by type
+   - Sort sessions by date
+
+2. Use Gemini for final aggregation:
+   gemini -p "
+   PURPOSE: Aggregate lessons and conflicts from all workflow sessions
+   TASK:
+   • Group successes by functional domain
+   • Categorize challenges by severity (HIGH/MEDIUM/LOW)
+   • Identify recurring conflict patterns
+   • Calculate frequencies and prioritize
+   MODE: analysis
+   CONTEXT: [Provide aggregated JSON data]
+   EXPECTED: Final aggregated structure for SKILL documents
+   RULES: Template reference from skill-aggregation.txt
+   "
+
+3. Read templates for formatting (same 4 templates as single mode)
+
+4. Generate all SKILL documents:
+   - sessions-timeline.md (all sessions, sorted by date)
+   - lessons-learned.md (aggregated lessons with frequencies)
+   - conflict-patterns.md (recurring patterns with resolutions)
+   - SKILL.md (index with progressive loading)
+
+5. Write files to .claude/skills/workflow-progress/
+
+6. Return result JSON:
+   {
+     "status": "success",
+     "sessions_processed": count,
+     "files_generated": ["SKILL.md", "sessions-timeline.md", ...],
+     "summary": {
+       "total_sessions": count,
+       "functional_domains": [...],
+       "date_range": "...",
+       "lessons_count": count,
+       "conflicts_count": count
+     }
+   }
+```
+
+---
+
+### Phase 3: Verification
+
+**Step 3.1: Check SKILL Package Files**
+```bash
+bash(ls -lh .claude/skills/workflow-progress/)
+```
+
+Verify all 4 files exist:
+- SKILL.md
+- sessions-timeline.md
+- lessons-learned.md
+- conflict-patterns.md
+
+**Step 3.2: TodoWrite Completion**
+
+Mark all tasks as completed.
+
+**Step 3.3: Display Summary**
+
+**Single Session Mode**:
+```
+Session {session_id} processed successfully
+
+Updated:
+- sessions-timeline.md
+- lessons-learned.md
+- conflict-patterns.md
+- SKILL.md
+
+SKILL Location: .claude/skills/workflow-progress/SKILL.md
+```
+
+**All Sessions Mode**:
+```
+All sessions processed in parallel
+
+Sessions: {count} total
+Functional Domains: {domain_list}
+Date Range: {earliest} - {latest}
+
+Generated:
+- sessions-timeline.md ({count} sessions)
+- lessons-learned.md ({lessons_count} lessons)
+- conflict-patterns.md ({conflicts_count} conflicts)
+- SKILL.md (4-level progressive loading)
+
+SKILL Location: .claude/skills/workflow-progress/SKILL.md
+
+Usage:
+- Level 0: Quick refresh (~2K tokens)
+- Level 1: Recent history (~8K tokens)
+- Level 2: Complete analysis (~25K tokens)
+- Level 3: Deep dive (~40K tokens)
+```
+
+---
+
+## Agent Guidelines
+
+### Agent Capabilities
+
+**universal-executor agents can**:
+- Read files from `.workflow/.archives/`
+- Execute bash commands
+- Call Gemini CLI for intelligent analysis
+- Read template files for formatting guidance
+- Write SKILL package files (single mode) or return JSON (parallel mode)
+- Return structured results
+
+### Gemini Usage Pattern
+
+**When to use Gemini**:
+- Aggregating lessons from multiple sources
+- Identifying recurring patterns
+- Classifying conflicts by type and severity
+- Extracting structured data from IMPL_PLAN
+
+**Fallback Strategy**: If Gemini fails or times out, use direct file parsing with structured extraction logic.
+
+---
+
+## Template System
+
+### Template Files
+
+All templates located in: `~/.claude/workflows/cli-templates/prompts/workflow/`
+
+1. **skill-sessions-timeline.txt**: Format for sessions-timeline.md
+2. **skill-lessons-learned.txt**: Format for lessons-learned.md
+3. **skill-conflict-patterns.txt**: Format for conflict-patterns.md
+4. **skill-index.txt**: Format for SKILL.md index
+5. **skill-aggregation.txt**: Rules for Gemini aggregation (existing)
+
+### Template Usage in Agent
+
+**Agents read templates to understand**:
+- File structure and markdown format
+- Data sources (which files to read)
+- Update strategy (incremental vs full)
+- Formatting rules and conventions
+- Aggregation logic (for Gemini)
+
+**Templates are NOT shown in this command documentation** - agents read them directly as needed.
+
+---
+
+## Error Handling
+
+### Validation Errors
+- **No archives directory**: "Error: No workflow archives found at .workflow/.archives/"
+- **Invalid session ID format**: "Error: Invalid session ID format. Only WFS-* sessions are supported"
+- **Session not found**: "Error: Session {session_id} not found in archives"
+- **No WFS sessions in manifest**: "Error: No WFS-* workflow sessions found in manifest.json"
+
+### Agent Errors
+- If agent fails, report error message from agent result
+- If Gemini times out, agents use fallback direct parsing
+- If template read fails, agents use inline format
+
+### Recovery
+- Single session mode: Can be retried without affecting other sessions
+- All sessions mode: If one agent fails, others continue; retry failed sessions individually
+
+
+
+## Integration
+
+### Called by `/workflow:session:complete`
+
+Automatically invoked after session archival:
+```bash
+SlashCommand(command="/memory:workflow-skill-memory session {session_id}")
+```
+
+### Manual Invocation
+
+Users can manually process sessions:
+```bash
+/memory:workflow-skill-memory session WFS-custom-feature  # Single session
+/memory:workflow-skill-memory all                         # Full regeneration
+```

.claude/commands/task/breakdown.md

@@ -1,6 +1,6 @@
 ---
 name: breakdown
-description: Intelligent task decomposition with context-aware subtask generation
+description: Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order
 argument-hint: "task-id"
 ---
 
@@ -15,7 +15,7 @@ Breaks down complex tasks into executable subtasks with context inheritance and
 
 ## Core Features
 
-⚠️ **CRITICAL**: Manual breakdown with safety controls to prevent file conflicts and task limit violations.
+**CRITICAL**: Manual breakdown with safety controls to prevent file conflicts and task limit violations.
 
 ### Breakdown Process
 1. **Session Check**: Verify active session contains parent task
@@ -50,7 +50,7 @@ Interactive process:
 Task: Build authentication module
 Current total tasks: 6/10
 
-⚠️  MANUAL BREAKDOWN REQUIRED
+MANUAL BREAKDOWN REQUIRED
 Define subtasks manually (remaining capacity: 4 tasks):
 
 1. Enter subtask title: User authentication core
@@ -59,11 +59,11 @@ Define subtasks manually (remaining capacity: 4 tasks):
 2. Enter subtask title: OAuth integration
    Focus files: services/OAuthService.js, routes/oauth.js
 
-⚠️  FILE CONFLICT DETECTED:
+FILE CONFLICT DETECTED:
    - routes/auth.js appears in multiple subtasks
    - Recommendation: Merge related authentication routes
 
-⚠️  SIMILAR FUNCTIONALITY WARNING:
+SIMILAR FUNCTIONALITY WARNING:
    - "User authentication" and "OAuth integration" both handle auth
    - Consider combining into single task
 
@@ -83,10 +83,10 @@ AskUserQuestion({
 
 User selected: "Proceed with breakdown"
 
-✅ Task IMPL-1 broken down:
-▸ IMPL-1: Build authentication module (container)
-  ├── IMPL-1.1: User authentication core → @code-developer
-  └── IMPL-1.2: OAuth integration → @code-developer
+Task IMPL-1 broken down:
+IMPL-1: Build authentication module (container)
+  ├── IMPL-1.1: User authentication core -> @code-developer
+  └── IMPL-1.2: OAuth integration -> @code-developer
 
 Files updated: .task/IMPL-1.json + 2 subtask files + TODO_LIST.md
 ```
@@ -167,45 +167,38 @@ Files updated: .task/IMPL-1.json + 2 subtask files + TODO_LIST.md
 ```bash
 /task:breakdown impl-1
 
-▸ impl-1: Build authentication (container)
-  ├── impl-1.1: Design schema → @planning-agent
-  ├── impl-1.2: Implement logic + tests → @code-developer
-  └── impl-1.3: Execute & fix tests → @test-fix-agent
+impl-1: Build authentication (container)
+  ├── impl-1.1: Design schema -> @planning-agent
+  ├── impl-1.2: Implement logic + tests -> @code-developer
+  └── impl-1.3: Execute & fix tests -> @test-fix-agent
 ```
 
 ## Error Handling
 
 ```bash
 # Task not found
-❌ Task IMPL-5 not found
+Task IMPL-5 not found
 
 # Already broken down
-⚠️ Task IMPL-1 already has subtasks
+Task IMPL-1 already has subtasks
 
 # Wrong status
-❌ Cannot breakdown completed task IMPL-2
+Cannot breakdown completed task IMPL-2
 
 # 10-task limit exceeded
-❌ Breakdown would exceed 10-task limit (current: 8, proposed: 4)
-   Suggestion: Re-scope project into smaller iterations
+Breakdown would exceed 10-task limit (current: 8, proposed: 4)
+Suggestion: Re-scope project into smaller iterations
 
 # File conflicts detected
-⚠️ File conflict: routes/auth.js appears in IMPL-1.1 and IMPL-1.2
-   Recommendation: Merge subtasks or redistribute files
+File conflict: routes/auth.js appears in IMPL-1.1 and IMPL-1.2
+Recommendation: Merge subtasks or redistribute files
 
 # Similar functionality warning
-⚠️ Similar functions detected: "user login" and "authentication"
-   Consider consolidating related functionality
+Similar functions detected: "user login" and "authentication"
+Consider consolidating related functionality
 
 # Manual breakdown required
-❌ Automatic breakdown disabled. Use manual breakdown process.
+Automatic breakdown disabled. Use manual breakdown process.
 ```
 
-## Related Commands
-
-- `/task:create` - Create new tasks
-- `/task:execute` - Execute subtasks
-- `/workflow:status` - View task hierarchy
-- `/workflow:plan` - Plan within 10-task limit
-
 **System ensures**: Manual breakdown control with file cohesion enforcement, similar functionality detection, and 10-task limit compliance

.claude/commands/task/create.md

@@ -1,6 +1,6 @@
 ---
 name: create
-description: Create implementation tasks with automatic context awareness
+description: Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis
 argument-hint: "\"task title\""
 ---
 
@@ -37,7 +37,7 @@ Creates new implementation tasks with automatic context awareness and ID generat
 
 Output:
 ```
-✅ Task created: IMPL-1
+Task created: IMPL-1
 Title: Build authentication module
 Type: feature
 Agent: code-developer
@@ -73,7 +73,7 @@ Status: pending
 ### Analysis Triggers
 When implementation details incomplete:
 ```bash
-⚠️ Task requires analysis for implementation details
+Task requires analysis for implementation details
 Suggest running: gemini analysis for file locations and dependencies
 ```
 
@@ -117,16 +117,16 @@ Based on task type and title keywords:
 
 ```bash
 # No workflow session
-❌ No active workflow found
-→ Use: /workflow init "project name"
+No active workflow found
+Use: /workflow init "project name"
 
 # Duplicate task
-⚠️ Similar task exists: IMPL-3
-→ Continue anyway? (y/n)
+Similar task exists: IMPL-3
+Continue anyway? (y/n)
 
 # Max depth exceeded
-❌ Cannot create IMPL-1.2.1 (max 2 levels)
-→ Use: IMPL-2 for new main task
+Cannot create IMPL-1.2.1 (max 2 levels)
+Use: IMPL-2 for new main task
 ```
 
 ## Examples
@@ -135,7 +135,7 @@ Based on task type and title keywords:
 ```bash
 /task:create "Implement user authentication"
 
-✅ Created IMPL-1: Implement user authentication
+Created IMPL-1: Implement user authentication
 Type: feature
 Agent: code-developer
 Status: pending
@@ -145,14 +145,8 @@ Status: pending
 ```bash
 /task:create "Fix login validation bug" --type=bugfix
 
-✅ Created IMPL-2: Fix login validation bug
+Created IMPL-2: Fix login validation bug
 Type: bugfix
 Agent: code-developer
 Status: pending
-```
-
-## Related Commands
-
-- `/task:breakdown` - Break into subtasks
-- `/task:execute` - Execute with agent
-- `/context` - View task details
+```

.claude/commands/task/execute.md

@@ -1,15 +1,15 @@
 ---
 name: execute
-description: Execute tasks with appropriate agents and context-aware orchestration
+description: Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking
 argument-hint: "task-id"
 ---
 
-### 🚀 **Command Overview: `/task:execute`**
+## Command Overview: /task:execute
 
--   **Purpose**: Executes tasks using intelligent agent selection, context preparation, and progress tracking.
+**Purpose**: Executes tasks using intelligent agent selection, context preparation, and progress tracking.
 
 
-### ⚙️ **Execution Modes**
+## Execution Modes
 
 -   **auto (Default)**
     -   Fully autonomous execution with automatic agent selection.
@@ -22,7 +22,7 @@ argument-hint: "task-id"
     -   Optional manual review using `@universal-executor`.
     -   Used only when explicitly requested by user.
 
-### 🤖 **Agent Selection Logic**
+## Agent Selection Logic
 
 The system determines the appropriate agent for a task using the following logic.
 
@@ -52,11 +52,11 @@ FUNCTION select_agent(task, agent_override):
 END FUNCTION
 ```
 
-### 🔄 **Core Execution Protocol**
+## Core Execution Protocol
 
-`Pre-Execution` **->** `Execution` **->** `Post-Execution`
+`Pre-Execution` -> `Execution` -> `Post-Execution`
 
-### ✅ **Pre-Execution Protocol**
+### Pre-Execution Protocol
 
 `Validate Task & Dependencies` **->** `Prepare Execution Context` **->** `Coordinate with TodoWrite`
 
@@ -65,7 +65,7 @@ END FUNCTION
 -   **Session Context Injection**: Provides workflow directory paths to agents for TODO_LIST.md and summary management.
 -   **TodoWrite Coordination**: Generates execution Todos and checkpoints, syncing with `TODO_LIST.md`.
 
-### 🏁 **Post-Execution Protocol**
+### Post-Execution Protocol
 
 `Update Task Status` **->** `Generate Summary` **->** `Save Artifacts` **->** `Sync All Progress` **->** `Validate File Integrity`
 
@@ -73,7 +73,7 @@ END FUNCTION
 -   Creates a summary in `.summaries/`.
 -   Stores outputs and syncs progress across the entire workflow session.
 
-### 🧠 **Task & Subtask Execution Logic**
+### Task & Subtask Execution Logic
 
 This logic defines how single, multiple, or parent tasks are handled.
 
@@ -99,7 +99,7 @@ FUNCTION execute_task_command(task_id, mode, parallel_flag):
 END FUNCTION
 ```
 
-### 🛡️ **Error Handling & Recovery Logic**
+### Error Handling & Recovery Logic
 
 ```pseudo
 FUNCTION pre_execution_check(task):
@@ -124,7 +124,7 @@ END FUNCTION
 ```
 
 
-### 📄 **Simplified Context Structure (JSON)**
+### Simplified Context Structure (JSON)
 
 This is the simplified data structure loaded to provide context for task execution.
 
@@ -189,7 +189,7 @@ This is the simplified data structure loaded to provide context for task executi
       "pre_analysis": [
         {
           "action": "analyze patterns",
-          "template": "~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt",
+          "template": "~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt",
           "method": "gemini"
         }
       ]
@@ -213,7 +213,7 @@ This is the simplified data structure loaded to provide context for task executi
 }
 ```
 
-### 🎯 **Agent-Specific Context**
+### Agent-Specific Context
 
 Different agents receive context tailored to their function, including implementation details:
 
@@ -243,13 +243,13 @@ Different agents receive context tailored to their function, including implement
 - Dependency validation from implementation.context_notes.dependencies
 - Architecture compliance checks
 
-### 🗃️ **Simplified File Output**
+### Simplified File Output
 
 -   **Task JSON File (`.task/<task-id>.json`)**: Updated with status and last attempt time only.
 -   **Session File (`workflow-session.json`)**: Updated task stats (completed count).
 -   **Summary File**: Generated in `.summaries/` upon completion (optional).
 
-### 📝 **Simplified Summary Template**
+### Simplified Summary Template
 
 Optional summary file generated at `.summaries/IMPL-[task-id]-summary.md`.
 

.claude/commands/task/replan.md

@@ -1,6 +1,6 @@
 ---
 name: replan
-description: Replan individual tasks with detailed user input and change tracking
+description: Update task JSON with new requirements or batch-update multiple tasks from verification report, tracks changes in task-changes.json
 argument-hint: "task-id [\"text\"|file.md] | --batch [verification-report.md]"
 allowed-tools: Read(*), Write(*), Edit(*), TodoWrite(*), Glob(*), Bash(*)
 ---
@@ -24,7 +24,7 @@ Replans individual tasks or batch processes multiple tasks with change tracking
 - **Change Documentation**: Track all modifications
 - **Progress Tracking**: TodoWrite integration for batch operations
 
-⚠️ **CRITICAL**: Validates active session before replanning
+**CRITICAL**: Validates active session before replanning
 
 ## Operation Modes
 
@@ -189,7 +189,7 @@ AskUserQuestion({
 
 User selected: "Yes, rollback"
 
-✅ Task rolled back to version 1.1
+Task rolled back to version 1.1
 ```
 
 ## Batch Processing with TodoWrite
@@ -201,7 +201,7 @@ When processing multiple tasks, automatically creates TodoWrite task list:
 **Batch Replan Progress**:
 - [x] IMPL-002: Add FR-12 draft saving acceptance criteria
 - [x] IMPL-003: Add FR-14 history tracking acceptance criteria
-- [⧗] IMPL-004: Add FR-09 response surface explicit coverage
+- [ ] IMPL-004: Add FR-09 response surface explicit coverage
 - [ ] IMPL-008: Add NFR performance validation steps
 ```
 
@@ -255,9 +255,9 @@ AskUserQuestion({
 
 User selected: "Yes, apply"
 
-✓ Version 1.2 created
-✓ Context updated
-✓ Backup saved to .task/backup/IMPL-1-v1.1.json
+Version 1.2 created
+Context updated
+Backup saved to .task/backup/IMPL-1-v1.1.json
 ```
 
 ### Single Task - File Input
@@ -267,9 +267,9 @@ User selected: "Yes, apply"
 Loading requirements.md...
 Applying specification changes...
 
-✓ Task updated with new requirements
-✓ Version 1.1 created
-✓ Backup saved to .task/backup/IMPL-2-v1.0.json
+Task updated with new requirements
+Version 1.1 created
+Backup saved to .task/backup/IMPL-2-v1.0.json
 ```
 
 ### Batch Mode - From Verification Report
@@ -286,23 +286,23 @@ Found 4 tasks requiring replanning:
 Creating task tracking list...
 
 Processing IMPL-002...
-✓ Backup created: .task/backup/IMPL-002-v1.0.json
-✓ Updated to v1.1
+Backup created: .task/backup/IMPL-002-v1.0.json
+Updated to v1.1
 
 Processing IMPL-003...
-✓ Backup created: .task/backup/IMPL-003-v1.0.json
-✓ Updated to v1.1
+Backup created: .task/backup/IMPL-003-v1.0.json
+Updated to v1.1
 
 Processing IMPL-004...
-✓ Backup created: .task/backup/IMPL-004-v1.0.json
-✓ Updated to v1.1
+Backup created: .task/backup/IMPL-004-v1.0.json
+Updated to v1.1
 
 Processing IMPL-008...
-✓ Backup created: .task/backup/IMPL-008-v1.0.json
-✓ Updated to v1.1
+Backup created: .task/backup/IMPL-008-v1.0.json
+Updated to v1.1
 
-✅ Batch replan completed: 4/4 successful
-📋 Summary report saved
+Batch replan completed: 4/4 successful
+Summary report saved
 ```
 
 ### Batch Mode - Auto-detection
@@ -320,35 +320,35 @@ Entering batch mode...
 ### Single Task Errors
 ```bash
 # Task not found
-❌ Task IMPL-5 not found
-→ Check task ID with /workflow:status
+Task IMPL-5 not found
+Check task ID with /workflow:status
 
 # Task completed
-⚠️ Task IMPL-1 is completed (cannot replan)
-→ Create new task for additional work
+Task IMPL-1 is completed (cannot replan)
+Create new task for additional work
 
 # File not found
-❌ File requirements.md not found
-→ Check file path
+File requirements.md not found
+Check file path
 
 # No input provided
-❌ Please specify changes needed
-→ Provide text, file, or verification report
+Please specify changes needed
+Provide text, file, or verification report
 ```
 
 ### Batch Mode Errors
 ```bash
 # Invalid verification report
-❌ File does not contain valid verification report format
-→ Check report structure or use single task mode
+File does not contain valid verification report format
+Check report structure or use single task mode
 
 # Partial failures
-⚠️ Batch completed with errors: 3/4 successful
-→ Review error details in summary report
+Batch completed with errors: 3/4 successful
+Review error details in summary report
 
 # No replan recommendations found
-❌ Verification report contains no replan recommendations
-→ Check report content or use /workflow:action-plan-verify first
+Verification report contains no replan recommendations
+Check report content or use /workflow:action-plan-verify first
 ```
 
 ## Batch Mode Integration
@@ -429,16 +429,4 @@ TodoWrite({
 TodoWrite({
   todos: updateTaskStatus(taskId, "completed")
 });
-```
-
-## Related Commands
-
-- `/workflow:status` - View task structure and versions
-- `/workflow:action-plan-verify` - Generate verification report for batch mode
-- `/task:execute` - Execute replanned task
-- `/task:create` - Create new tasks
-- `/task:breakdown` - Break down complex tasks
-
-## Context
-
-$ARGUMENTS
+```

.claude/commands/version.md

@@ -1,6 +1,6 @@
 ---
 name: version
-description: Display version information and check for updates
+description: Display Claude Code version information and check for updates
 allowed-tools: Bash(*)
 ---
 
@@ -152,12 +152,12 @@ bash(printf "%s\n%s" "3.2.1" "3.2.2" | sort -V | tail -n 1)
 
 **Scenario 1: Up to date**
 ```
-✅ You are on the latest stable version (3.2.1)
+You are on the latest stable version (3.2.1)
 ```
 
 **Scenario 2: Upgrade available**
 ```
-⬆️ A newer stable version is available: v3.2.2
+A newer stable version is available: v3.2.2
 Your version: 3.2.1
 
 To upgrade:
@@ -167,7 +167,7 @@ Bash: bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-W
 
 **Scenario 3: Development version**
 ```
-✨ You are running a development version (3.4.0-dev)
+You are running a development version (3.4.0-dev)
 This is newer than the latest stable release (v3.3.0)
 ```
 
@@ -252,7 +252,3 @@ ERROR: version.json is invalid or corrupted
 
 ### Timeout Configuration
 All network calls should use `timeout: 30000` (30 seconds) to handle slow connections.
-
-## Related Commands
-- `/cli:cli-init` - Initialize CLI configurations
-- `/workflow:session:list` - List workflow sessions

.claude/commands/workflow/action-plan-verify.md

@@ -1,6 +1,6 @@
 ---
 name: action-plan-verify
-description: Perform non-destructive cross-artifact consistency and quality analysis of IMPL_PLAN.md and task.json before execution
+description: Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation
 argument-hint: "[optional: --session session-id]"
 allowed-tools: Read(*), TodoWrite(*), Glob(*), Bash(*)
 ---
@@ -242,10 +242,10 @@ Output a Markdown report (no file writes) with the following structure:
 
 | Requirement ID | Requirement Summary | Has Task? | Task IDs | Priority Match | Notes |
 |----------------|---------------------|-----------|----------|----------------|-------|
-| FR-01 | User authentication | ✅ Yes | IMPL-1.1, IMPL-1.2 | ✅ Match | Complete |
-| FR-02 | Data export | ✅ Yes | IMPL-2.3 | ⚠️ Mismatch | High req → Med priority task |
-| FR-03 | Profile management | ❌ No | - | - | **CRITICAL: Zero coverage** |
-| NFR-01 | Response time <200ms | ❌ No | - | - | **HIGH: No performance tasks** |
+| FR-01 | User authentication | Yes | IMPL-1.1, IMPL-1.2 | Match | Complete |
+| FR-02 | Data export | Yes | IMPL-2.3 | Mismatch | High req → Med priority task |
+| FR-03 | Profile management | No | - | - | **CRITICAL: Zero coverage** |
+| NFR-01 | Response time <200ms | No | - | - | **HIGH: No performance tasks** |
 
 **Coverage Metrics**:
 - Functional Requirements: 85% (17/20 covered)
@@ -264,7 +264,7 @@ Output a Markdown report (no file writes) with the following structure:
 
 ### Dependency Graph Issues
 
-**Circular Dependencies**: None detected ✅
+**Circular Dependencies**: None detected
 
 **Broken Dependencies**:
 - IMPL-2.3 depends on "IMPL-2.4" (non-existent)
@@ -323,12 +323,12 @@ Output a Markdown report (no file writes) with the following structure:
 #### Action Recommendations
 
 **If CRITICAL Issues Exist**:
-- ❌ **BLOCK EXECUTION** - Resolve critical issues before proceeding
+- **BLOCK EXECUTION** - Resolve critical issues before proceeding
 - Use TodoWrite to track all required fixes
 - Fix broken dependencies and circular references
 
 **If Only HIGH/MEDIUM/LOW Issues**:
-- ⚠️ **PROCEED WITH CAUTION** - Fix high-priority issues first
+- **PROCEED WITH CAUTION** - Fix high-priority issues first
 - Use TodoWrite to systematically track and complete all improvements
 
 #### TodoWrite-Based Remediation Workflow

.claude/commands/workflow/brainstorm/api-designer.md

@@ -1,6 +1,6 @@
 ---
 name: api-designer
-description: Generate or update api-designer/analysis.md addressing guidance-specification discussion points
+description: Generate or update api-designer/analysis.md addressing guidance-specification discussion points for API design perspective
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---

.claude/commands/workflow/brainstorm/artifacts.md

@@ -1,6 +1,6 @@
 ---
 name: artifacts
-description: Interactive clarification generating confirmed guidance specification
+description: Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis
 argument-hint: "topic or challenge description [--count N]"
 allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*)
 ---

.claude/commands/workflow/brainstorm/auto-parallel.md

@@ -1,6 +1,6 @@
 ---
 name: auto-parallel
-description: Parallel brainstorming automation with dynamic role selection and concurrent execution
+description: Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives
 argument-hint: "topic or challenge description" [--count N]
 allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)
 ---

.claude/commands/workflow/brainstorm/data-architect.md

@@ -1,6 +1,6 @@
 ---
 name: data-architect
-description: Generate or update data-architect/analysis.md addressing guidance-specification discussion points
+description: Generate or update data-architect/analysis.md addressing guidance-specification discussion points for data architecture perspective
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---

.claude/commands/workflow/brainstorm/product-manager.md

@@ -1,6 +1,6 @@
 ---
 name: product-manager
-description: Generate or update product-manager/analysis.md addressing guidance-specification discussion points
+description: Generate or update product-manager/analysis.md addressing guidance-specification discussion points for product management perspective
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---

.claude/commands/workflow/brainstorm/product-owner.md

@@ -1,6 +1,6 @@
 ---
 name: product-owner
-description: Generate or update product-owner/analysis.md addressing guidance-specification discussion points
+description: Generate or update product-owner/analysis.md addressing guidance-specification discussion points for product ownership perspective
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---

.claude/commands/workflow/brainstorm/scrum-master.md

@@ -1,6 +1,6 @@
 ---
 name: scrum-master
-description: Generate or update scrum-master/analysis.md addressing guidance-specification discussion points
+description: Generate or update scrum-master/analysis.md addressing guidance-specification discussion points for Agile process perspective
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---

.claude/commands/workflow/brainstorm/subject-matter-expert.md

@@ -1,6 +1,6 @@
 ---
 name: subject-matter-expert
-description: Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points
+description: Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points for domain expertise perspective
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---

.claude/commands/workflow/brainstorm/synthesis.md

@@ -1,6 +1,6 @@
 ---
 name: synthesis
-description: Clarify and refine role analyses through intelligent Q&A and targeted updates
+description: Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent
 argument-hint: "[optional: --session session-id]"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*), Edit(*), Glob(*)
 ---

.claude/commands/workflow/brainstorm/system-architect.md

@@ -1,6 +1,6 @@
 ---
 name: system-architect
-description: Generate or update system-architect/analysis.md addressing guidance-specification discussion points
+description: Generate or update system-architect/analysis.md addressing guidance-specification discussion points for system architecture perspective
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---

.claude/commands/workflow/brainstorm/ui-designer.md

@@ -1,6 +1,6 @@
 ---
 name: ui-designer
-description: Generate or update ui-designer/analysis.md addressing guidance-specification discussion points
+description: Generate or update ui-designer/analysis.md addressing guidance-specification discussion points for UI design perspective
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---

.claude/commands/workflow/brainstorm/ux-expert.md

@@ -1,6 +1,6 @@
 ---
 name: ux-expert
-description: Generate or update ux-expert/analysis.md addressing guidance-specification discussion points
+description: Generate or update ux-expert/analysis.md addressing guidance-specification discussion points for UX perspective
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---

.claude/commands/workflow/execute.md

@@ -1,6 +1,6 @@
 ---
 name: execute
-description: Coordinate agents for existing workflow tasks with automatic discovery
+description: Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking
 argument-hint: "[--resume-session=\"session-id\"]"
 ---
 
@@ -406,8 +406,8 @@ TodoWrite({
 #### TODO_LIST.md Update Timing
 **Single source of truth for task status** - enables lazy loading by providing task metadata without reading JSONs
 
-- **Before Agent Launch**: Mark task as `in_progress` (⚠️)
-- **After Task Complete**: Mark as `completed` (✅), advance to next
+- **Before Agent Launch**: Mark task as `in_progress`
+- **After Task Complete**: Mark as `completed`, advance to next
 - **On Error**: Keep as `in_progress`, add error note
 - **Workflow Complete**: Call `/workflow:session:complete`
 

.claude/commands/workflow/plan.md

@@ -1,6 +1,6 @@
 ---
 name: plan
-description: Orchestrate 5-phase planning workflow with quality gate, executing commands and passing context between phases
+description: 5-phase planning workflow with Gemini analysis and action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs with optional CLI auto-execution
 argument-hint: "[--agent] [--cli-execute] \"text description\"|file.md"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
@@ -153,7 +153,7 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 **Relationship with Brainstorm Phase**:
 - If brainstorm role analyses exist ([role]/analysis.md files), Phase 3 analysis incorporates them as input
-- **⚠️ User's original intent is ALWAYS primary**: New or refined user goals override brainstorm recommendations
+- **User's original intent is ALWAYS primary**: New or refined user goals override brainstorm recommendations
 - **Role analysis.md files define "WHAT"**: Requirements, design specs, role-specific insights
 - **IMPL_PLAN.md defines "HOW"**: Executable task breakdown, dependencies, implementation sequence
 - Task generation translates high-level role analyses into concrete, actionable work items
@@ -192,12 +192,12 @@ Planning complete for session: [sessionId]
 Tasks generated: [count]
 Plan: .workflow/[sessionId]/IMPL_PLAN.md
 
-✅ Recommended Next Steps:
+Recommended Next Steps:
 1. /workflow:action-plan-verify --session [sessionId]  # Verify plan quality before execution
 2. /workflow:status  # Review task breakdown
 3. /workflow:execute  # Start implementation (after verification)
 
-⚠️ Quality Gate: Consider running /workflow:action-plan-verify to catch issues early
+Quality Gate: Consider running /workflow:action-plan-verify to catch issues early
 ```
 
 ## TodoWrite Pattern
@@ -323,24 +323,24 @@ Return summary to user
 
 ## Coordinator Checklist
 
-✅ **Pre-Phase**: Convert user input to structured format (GOAL/SCOPE/CONTEXT)
-✅ Initialize TodoWrite before any command (Phase 3 added dynamically after Phase 2)
-✅ Execute Phase 1 immediately with structured description
-✅ Parse session ID from Phase 1 output, store in memory
-✅ Pass session ID and structured description to Phase 2 command
-✅ Parse context path from Phase 2 output, store in memory
-✅ **Extract conflict_risk from context-package.json**: Determine Phase 3 execution
-✅ **If conflict_risk ≥ medium**: Launch Phase 3 conflict-resolution with sessionId and contextPath
-✅ Wait for Phase 3 completion (if executed), verify CONFLICT_RESOLUTION.md created
-✅ **If conflict_risk is none/low**: Skip Phase 3, proceed directly to Phase 4
-✅ **Build Phase 4 command** based on flags:
+- **Pre-Phase**: Convert user input to structured format (GOAL/SCOPE/CONTEXT)
+- Initialize TodoWrite before any command (Phase 3 added dynamically after Phase 2)
+- Execute Phase 1 immediately with structured description
+- Parse session ID from Phase 1 output, store in memory
+- Pass session ID and structured description to Phase 2 command
+- Parse context path from Phase 2 output, store in memory
+- **Extract conflict_risk from context-package.json**: Determine Phase 3 execution
+- **If conflict_risk ≥ medium**: Launch Phase 3 conflict-resolution with sessionId and contextPath
+- Wait for Phase 3 completion (if executed), verify CONFLICT_RESOLUTION.md created
+- **If conflict_risk is none/low**: Skip Phase 3, proceed directly to Phase 4
+- **Build Phase 4 command** based on flags:
   - Base command: `/workflow:tools:task-generate` (or `-agent` if `--agent` flag)
   - Add `--session [sessionId]`
   - Add `--cli-execute` if flag present
-✅ Pass session ID to Phase 4 command
-✅ Verify all Phase 4 outputs
-✅ Update TodoWrite after each phase (dynamically adjust for Phase 3 presence)
-✅ After each phase, automatically continue to next phase based on TodoList status
+- Pass session ID to Phase 4 command
+- Verify all Phase 4 outputs
+- Update TodoWrite after each phase (dynamically adjust for Phase 3 presence)
+- After each phase, automatically continue to next phase based on TodoList status
 
 ## Structure Template Reference
 
@@ -368,3 +368,22 @@ CONSTRAINTS: [Limitations or boundaries]
 # Phase 2
 /workflow:tools:context-gather --session WFS-123 "GOAL: Build authentication\nSCOPE: JWT, login, registration\nCONTEXT: REST API"
 ```
+
+## Related Commands
+
+**Prerequisite Commands**:
+- `/workflow:brainstorm:artifacts` - Optional: Generate role-based analyses before planning (if complex requirements need multiple perspectives)
+- `/workflow:brainstorm:synthesis` - Optional: Refine brainstorm analyses with clarifications
+
+**Called by This Command** (5 phases):
+- `/workflow:session:start` - Phase 1: Create or discover workflow session
+- `/workflow:tools:context-gather` - Phase 2: Gather project context and analyze codebase
+- `/workflow:tools:conflict-resolution` - Phase 3: Detect and resolve conflicts (auto-triggered if conflict_risk ≥ medium)
+- `/compact` - Phase 3: Memory optimization (if context approaching limits)
+- `/workflow:tools:task-generate` - Phase 4: Generate task JSON files with manual approach
+- `/workflow:tools:task-generate-agent` - Phase 4: Generate task JSON files with agent-driven approach (when `--agent` flag used)
+
+**Follow-up Commands**:
+- `/workflow:action-plan-verify` - Recommended: Verify plan quality and catch issues before execution
+- `/workflow:status` - Review task breakdown and current progress
+- `/workflow:execute` - Begin implementation of generated tasks

.claude/commands/workflow/resume.md

@@ -1,6 +1,6 @@
 ---
 name: resume
-description: Intelligent workflow session resumption with automatic progress analysis
+description: Resume paused workflow session with automatic progress analysis, pending task identification, and conflict detection
 argument-hint: "session-id for workflow session to resume"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
@@ -89,5 +89,17 @@ The special `--resume-session` flag tells `/workflow:execute`:
 3. **Agent coordination**: TodoWrite and agent execution initiated successfully
 4. **Context preservation**: Session state and progress properly maintained
 
+## Related Commands
+
+**Prerequisite Commands**:
+- `/workflow:plan` or `/workflow:execute` - Workflow must be in progress or paused
+
+**Called by This Command** (2 phases):
+- `/workflow:status` - Phase 1: Analyze current session status and identify resume point
+- `/workflow:execute` - Phase 2: Resume execution with `--resume-session` flag
+
+**Follow-up Commands**:
+- None - Workflow continues automatically via `/workflow:execute`
+
 ---
 *Sequential command coordination for workflow session resumption*

.claude/commands/workflow/review.md

@@ -1,20 +1,20 @@
 ---
 name: review
-description: Optional specialized review (security, architecture, docs) for completed implementation
+description: Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini
 argument-hint: "[--type=security|architecture|action-items|quality] [optional: session-id]"
 ---
 
-### 🚀 Command Overview: `/workflow:review`
+## Command Overview: /workflow:review
 
 **Optional specialized review** for completed implementations. In the standard workflow, **passing tests = approved code**. Use this command only when specialized review is required (security, architecture, compliance, docs).
 
 ## Philosophy: "Tests Are the Review"
 
-- ✅ **Default**: All tests pass → Code approved
-- 🔍 **Optional**: Specialized reviews for:
-  - 🔒 Security audits (vulnerabilities, auth/authz)
-  - 🏗️ Architecture compliance (patterns, technical debt)
-  - 📋 Action items verification (requirements met, acceptance criteria)
+- **Default**: All tests pass -> Code approved
+- **Optional**: Specialized reviews for:
+  - Security audits (vulnerabilities, auth/authz)
+  - Architecture compliance (patterns, technical debt)
+  - Action items verification (requirements met, acceptance criteria)
 
 ## Review Types
 
@@ -44,13 +44,13 @@ fi
 
 # Step 2: Validation
 if [ ! -d ".workflow/${sessionId}" ]; then
-    echo "❌ Session ${sessionId} not found"
+    echo "Session ${sessionId} not found"
     exit 1
 fi
 
 # Check for completed tasks
 if [ ! -d ".workflow/${sessionId}/.summaries" ] || [ -z "$(find .workflow/${sessionId}/.summaries/ -name "IMPL-*.md" -type f 2>/dev/null)" ]; then
-    echo "❌ No completed implementation found. Complete implementation first"
+    echo "No completed implementation found. Complete implementation first"
     exit 1
 fi
 
@@ -59,7 +59,7 @@ review_type="${TYPE_ARG:-quality}"
 
 # Redirect docs review to specialized command
 if [ "$review_type" = "docs" ]; then
-    echo "💡 For documentation generation, please use:"
+    echo "For documentation generation, please use:"
     echo "   /workflow:tools:docs"
     echo ""
     echo "The docs command provides:"
@@ -73,7 +73,7 @@ fi
 # BASH_EXECUTION_STOPS → MODEL_ANALYSIS_BEGINS
 ```
 
-### 🧠 Model Analysis Phase
+### Model Analysis Phase
 
 After bash validation, the model takes control to:
 
@@ -205,7 +205,7 @@ After bash validation, the model takes control to:
    ```bash
    # If architecture or quality issues found, suggest memory update
    if [ "$review_type" = "architecture" ] || [ "$review_type" = "quality" ]; then
-       echo "💡 Consider updating project documentation:"
+       echo "Consider updating project documentation:"
        echo "   /update-memory-related"
    fi
    ```
@@ -226,7 +226,7 @@ After bash validation, the model takes control to:
 /workflow:review --type=docs
 ```
 
-## ✨ Features
+## Features
 
 - **Simple Validation**: Check session exists and has completed tasks
 - **No Complex Orchestration**: Direct analysis, no multi-phase pipeline
@@ -240,10 +240,10 @@ After bash validation, the model takes control to:
 
 ```
 Standard Workflow:
-  plan → execute → test-gen → execute ✅
+  plan -> execute -> test-gen -> execute (complete)
 
 Optional Review (when needed):
-  plan → execute → test-gen → execute → review (security/architecture/docs)
+  plan -> execute -> test-gen -> execute -> review (security/architecture/docs)
 ```
 
 **When to Use**:
@@ -256,11 +256,3 @@ Optional Review (when needed):
 - Regular development (tests are sufficient)
 - Simple bug fixes (test-fix-agent handles it)
 - Minor changes (update-memory-related is enough)
-
-## Related Commands
-
-- `/workflow:execute` - Must complete implementation first
-- `/workflow:test-gen` - Primary quality gate (tests)
-- `/workflow:tools:docs` - Generate hierarchical documentation (use instead of `--type=docs`)
-- `/update-memory-related` - Update CLAUDE.md docs after architecture findings
-- `/workflow:status` - Check session status

.claude/commands/workflow/session/complete.md

@@ -1,6 +1,6 @@
 ---
 name: complete
-description: Mark the active workflow session as complete and remove active flag
+description: Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag
 examples:
   - /workflow:session:complete
   - /workflow:session:complete --detailed
@@ -9,7 +9,7 @@ examples:
 # Complete Workflow Session (/workflow:session:complete)
 
 ## Overview
-Mark the currently active workflow session as complete, update its status, and remove the active flag marker.
+Mark the currently active workflow session as complete, analyze it for lessons learned, move it to the archive directory, and remove the active flag marker.
 
 ## Usage
 ```bash
@@ -19,87 +19,129 @@ Mark the currently active workflow session as complete, update its status, and r
 
 ## Implementation Flow
 
-### Step 1: Find Active Session
+### Phase 1: Prepare for Archival (Minimal Manual Operations)
+
+**Purpose**: Find active session, move to archive location, pass control to agent. Minimal operations.
+
+#### Step 1.1: Find Active Session and Get Name
 ```bash
-ls .workflow/.active-* 2>/dev/null | head -1
-```
+# Find active marker
+bash(find .workflow/ -name ".active-*" -type f | head -1)
 
-### Step 2: Get Session Name
+# Extract session name from marker path
+bash(basename .workflow/.active-WFS-session-name | sed 's/^\.active-//')
+```
+**Output**: Session name `WFS-session-name`
+
+#### Step 1.2: Move Session to Archive
 ```bash
-basename .workflow/.active-WFS-session-name | sed 's/^\.active-//'
+# Create archive directory if needed
+bash(mkdir -p .workflow/.archives/)
+
+# Move session to archive location
+bash(mv .workflow/WFS-session-name .workflow/.archives/WFS-session-name)
+```
+**Result**: Session now at `.workflow/.archives/WFS-session-name/`
+
+### Phase 2: Agent-Orchestrated Completion (All Data Processing)
+
+**Purpose**: Agent analyzes archived session, generates metadata, updates manifest, and removes active marker.
+
+#### Agent Invocation
+
+Invoke `universal-executor` agent to complete the archival process.
+
+**Agent Task**:
+```
+Task(
+  subagent_type="universal-executor",
+  description="Complete session archival",
+  prompt=`
+Complete workflow session archival. Session already moved to archive location.
+
+## Context
+- Session: .workflow/.archives/WFS-session-name/
+- Active marker: .workflow/.active-WFS-session-name
+
+## Tasks
+
+1. **Extract session data** from workflow-session.json (session_id, description/topic, started_at/timestamp, completed_at, status)
+   - If status != "completed", update it with timestamp
+
+2. **Count files**: tasks (.task/*.json) and summaries (.summaries/*.md)
+
+3. **Generate lessons**: Use gemini with ~/.claude/workflows/cli-templates/prompts/archive/analysis-simple.txt (fallback: analyze files directly)
+   - Return: {successes, challenges, watch_patterns}
+
+4. **Build archive entry**:
+   - Calculate: duration_hours, success_rate, tags (3-5 keywords)
+   - Construct complete JSON with session_id, description, archived_at, archive_path, metrics, tags, lessons
+
+5. **Update manifest**: Initialize .workflow/.archives/manifest.json if needed, append entry
+
+6. **Remove active marker**
+
+7. **Return result**: {"status": "success", "session_id": "...", "archived_at": "...", "metrics": {...}, "lessons_summary": {...}}
+
+## Error Handling
+- On failure: return {"status": "error", "task": "...", "message": "..."}
+- Do NOT remove marker if failed
+  `
+)
 ```
 
-### Step 3: Update Session Status
+**Expected Output**:
+- Agent returns JSON result confirming successful archival
+- Display completion summary to user based on agent response
+
+## Workflow Execution Strategy
+
+### Two-Phase Approach (Optimized)
+
+**Phase 1: Minimal Manual Setup** (2 simple operations)
+- Find active session and extract name
+- Move session to archive location
+- **No data extraction** - agent handles all data processing
+- **No counting** - agent does this from archive location
+- **Total**: 2 bash commands (find + move)
+
+**Phase 2: Agent-Driven Completion** (1 agent invocation)
+- Extract all session data from archived location
+- Count tasks and summaries
+- Generate lessons learned analysis
+- Build complete archive metadata
+- Update manifest
+- Remove active marker
+- Return success/error result
+
+## Quick Commands
+
 ```bash
-jq '.status = "completed"' .workflow/WFS-session/workflow-session.json > temp.json
-mv temp.json .workflow/WFS-session/workflow-session.json
+# Phase 1: Find and move
+bash(find .workflow/ -name ".active-*" -type f | head -1)
+bash(basename .workflow/.active-WFS-session-name | sed 's/^\.active-//')
+bash(mkdir -p .workflow/.archives/)
+bash(mv .workflow/WFS-session-name .workflow/.archives/WFS-session-name)
+
+# Phase 2: Agent completes archival
+Task(subagent_type="universal-executor", description="Complete session archival", prompt=`...`)
 ```
 
-### Step 4: Add Completion Timestamp
+## Archive Query Commands
+
+After archival, you can query the manifest:
+
 ```bash
-jq '.completed_at = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"' .workflow/WFS-session/workflow-session.json > temp.json
-mv temp.json .workflow/WFS-session/workflow-session.json
+# List all archived sessions
+jq '.archives[].session_id' .workflow/.archives/manifest.json
+
+# Find sessions by keyword
+jq '.archives[] | select(.description | test("auth"; "i"))' .workflow/.archives/manifest.json
+
+# Get specific session details
+jq '.archives[] | select(.session_id == "WFS-user-auth")' .workflow/.archives/manifest.json
+
+# List all watch patterns across sessions
+jq '.archives[].lessons.watch_patterns[]' .workflow/.archives/manifest.json
 ```
 
-### Step 5: Count Final Statistics
-```bash
-find .workflow/WFS-session/.task/ -name "*.json" -type f 2>/dev/null | wc -l
-find .workflow/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
-```
-
-### Step 6: Remove Active Marker
-```bash
-rm .workflow/.active-WFS-session-name
-```
-
-## Simple Bash Commands
-
-### Basic Operations
-- **Find active session**: `find .workflow/ -name ".active-*" -type f`
-- **Get session name**: `basename marker | sed 's/^\.active-//'`
-- **Update status**: `jq '.status = "completed"' session.json > temp.json`
-- **Add timestamp**: `jq '.completed_at = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"'`
-- **Count tasks**: `find .task/ -name "*.json" -type f | wc -l`
-- **Count completed**: `find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l`
-- **Remove marker**: `rm .workflow/.active-session`
-
-### Completion Result
-```
-Session WFS-user-auth completed
-- Status: completed
-- Started: 2025-09-15T10:00:00Z
-- Completed: 2025-09-15T16:30:00Z
-- Duration: 6h 30m
-- Total tasks: 8
-- Completed tasks: 8
-- Success rate: 100%
-```
-
-### Detailed Summary (--detailed flag)
-```
-Session Completion Summary:
-├── Session: WFS-user-auth
-├── Project: User authentication system
-├── Total time: 6h 30m
-├── Tasks completed: 8/8 (100%)
-├── Files generated: 24 files
-├── Summaries created: 8 summaries
-├── Status: All tasks completed successfully
-└── Location: .workflow/WFS-user-auth/
-```
-
-### Error Handling
-```bash
-# No active session
-find .workflow/ -name ".active-*" -type f 2>/dev/null || echo "No active session found"
-
-# Incomplete tasks
-task_count=$(find .task/ -name "*.json" -type f | wc -l)
-summary_count=$(find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l)
-test $task_count -eq $summary_count || echo "Warning: Not all tasks completed"
-```
-
-## Related Commands
-- `/workflow:session:list` - View all sessions including completed
-- `/workflow:session:start` - Start new session
-- `/workflow:status` - Check completion status before completing

.claude/commands/workflow/session/list.md

@@ -1,6 +1,6 @@
 ---
 name: list
-description: List all workflow sessions with status
+description: List all workflow sessions with status filtering, shows session metadata and progress information
 examples:
   - /workflow:session:list
 ---
@@ -59,19 +59,19 @@ jq -r '.created_at // "unknown"' .workflow/WFS-session/workflow-session.json
 ```
 Workflow Sessions:
 
-✅ WFS-oauth-integration (ACTIVE)
+[ACTIVE] WFS-oauth-integration
    Project: OAuth2 authentication system
    Status: active
    Progress: 3/8 tasks completed
    Created: 2025-09-15T10:30:00Z
 
-⏸️ WFS-user-profile (PAUSED)
+[PAUSED] WFS-user-profile
    Project: User profile management
    Status: paused
    Progress: 1/5 tasks completed
    Created: 2025-09-14T14:15:00Z
 
-📁 WFS-database-migration (COMPLETED)
+[COMPLETED] WFS-database-migration
    Project: Database schema migration
    Status: completed
    Progress: 4/4 tasks completed
@@ -81,10 +81,10 @@ Total: 3 sessions (1 active, 1 paused, 1 completed)
 ```
 
 ### Status Indicators
-- **✅**: Active session
-- **⏸️**: Paused session
-- **📁**: Completed session
-- **❌**: Error/corrupted session
+- **[ACTIVE]**: Active session
+- **[PAUSED]**: Paused session
+- **[COMPLETED]**: Completed session
+- **[ERROR]**: Error/corrupted session
 
 ### Quick Commands
 ```bash
@@ -96,9 +96,4 @@ ls .workflow/.active-* | basename | sed 's/^\.active-//'
 
 # Show recent sessions
 ls -t .workflow/WFS-*/workflow-session.json | head -3
-```
-
-## Related Commands
-- `/workflow:session:start` - Create new session
-- `/workflow:session:switch` - Switch to different session
-- `/workflow:session:status` - Detailed session info
+```

.claude/commands/workflow/session/resume.md

@@ -1,6 +1,6 @@
 ---
 name: resume
-description: Resume the most recently paused workflow session
+description: Resume the most recently paused workflow session with automatic session discovery and status update
 ---
 
 # Resume Workflow Session (/workflow:session:resume)
@@ -64,9 +64,4 @@ Session WFS-user-auth resumed
 - Paused at: 2025-09-15T14:30:00Z
 - Resumed at: 2025-09-15T15:45:00Z
 - Ready for: /workflow:execute
-```
-
-## Related Commands
-- `/workflow:session:pause` - Pause current session
-- `/workflow:execute` - Continue workflow execution
-- `/workflow:session:list` - Show all sessions
+```

.claude/commands/workflow/session/start.md

@@ -1,6 +1,6 @@
 ---
 name: start
-description: Discover existing sessions or start a new workflow session with intelligent session management
+description: Discover existing sessions or start new workflow session with intelligent session management and conflict detection
 argument-hint: [--auto|--new] [optional: task description for new session]
 examples:
   - /workflow:session:start
@@ -212,9 +212,4 @@ bash(echo '{"session_id":"WFS-test","project":"test project","status":"planning"
 - Pattern: `WFS-[lowercase-slug]`
 - Characters: `a-z`, `0-9`, `-` only
 - Max length: 50 characters
-- Uniqueness: Add numeric suffix if collision (`WFS-auth-2`, `WFS-auth-3`)
-
-## Related Commands
-- `/workflow:plan` - Uses `--auto` mode for session management
-- `/workflow:execute` - Uses discovery mode for session selection
-- `/workflow:session:status` - Shows detailed session information
+- Uniqueness: Add numeric suffix if collision (`WFS-auth-2`, `WFS-auth-3`)

.claude/commands/workflow/status.md

@@ -1,6 +1,6 @@
 ---
 name: workflow:status
-description: Generate on-demand views from JSON task data
+description: Generate on-demand task status views from JSON task data with optional task-id filtering for detailed view
 argument-hint: "[optional: task-id]"
 ---
 
@@ -51,11 +51,11 @@ find .workflow/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
 **Progress**: 3/8 tasks completed
 
 ## Active Tasks
-- [⚠️] impl-1: Current task in progress
+- [IN PROGRESS] impl-1: Current task in progress
 - [ ] impl-2: Next pending task
 
 ## Completed Tasks
-- [✅] impl-0: Setup completed
+- [COMPLETED] impl-0: Setup completed
 ```
 
 ## Simple Bash Commands
@@ -112,13 +112,8 @@ Summary: .summaries/impl-1-summary.md
 
 ### Validation Results
 ```
-✅ Session file valid
-✅ 8 task files found
-✅ 3 summaries found
-⚠️ 5 tasks pending completion
-```
-
-## Related Commands
-- `/workflow:execute` - Uses this for task discovery
-- `/workflow:resume` - Uses this for progress analysis
-- `/workflow:session:status` - Shows session metadata
+Session file valid
+8 task files found
+3 summaries found
+5 tasks pending completion
+```

.claude/commands/workflow/tdd-plan.md

@@ -1,6 +1,6 @@
 ---
 name: tdd-plan
-description: Orchestrate TDD workflow planning with Red-Green-Refactor task chains
+description: TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking
 argument-hint: "[--agent] \"feature description\"|file.md"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
@@ -171,14 +171,14 @@ Total tasks: [M] (1 task per simple feature + subtasks for complex features)
 Task breakdown:
 - Simple features: [K] tasks (IMPL-1 to IMPL-K)
 - Complex features: [L] features with [P] subtasks
-- Total task count: [M] (within 10-task limit ✅)
+- Total task count: [M] (within 10-task limit)
 
 Structure:
-- IMPL-1: {Feature 1 Name} (Internal: 🔴 Red → 🟢 Green → 🔵 Refactor)
-- IMPL-2: {Feature 2 Name} (Internal: 🔴 Red → 🟢 Green → 🔵 Refactor)
+- IMPL-1: {Feature 1 Name} (Internal: Red → Green → Refactor)
+- IMPL-2: {Feature 2 Name} (Internal: Red → Green → Refactor)
 - IMPL-3: {Complex Feature} (Container)
-  - IMPL-3.1: {Sub-feature A} (Internal: 🔴 Red → 🟢 Green → 🔵 Refactor)
-  - IMPL-3.2: {Sub-feature B} (Internal: 🔴 Red → 🟢 Green → 🔵 Refactor)
+  - IMPL-3.1: {Sub-feature A} (Internal: Red → Green → Refactor)
+  - IMPL-3.2: {Sub-feature B} (Internal: Red → Green → Refactor)
 [...]
 
 Plans generated:
@@ -192,12 +192,12 @@ TDD Configuration:
 - Green phase includes test-fix cycle (max 3 iterations)
 - Auto-revert on max iterations reached
 
-✅ Recommended Next Steps:
+Recommended Next Steps:
 1. /workflow:action-plan-verify --session [sessionId]  # Verify TDD plan quality and dependencies
 2. /workflow:execute --session [sessionId]  # Start TDD execution
 3. /workflow:tdd-verify [sessionId]  # Post-execution TDD compliance check
 
-⚠️ Quality Gate: Consider running /workflow:action-plan-verify to validate TDD task structure and dependencies
+Quality Gate: Consider running /workflow:action-plan-verify to validate TDD task structure and dependencies
 ```
 
 ## TodoWrite Pattern
@@ -258,11 +258,6 @@ Convert user input to TDD-structured format:
 - **Command failure**: Keep phase in_progress, report error
 - **TDD validation failure**: Report incomplete chains or wrong dependencies
 
-## Related Commands
-- `/workflow:plan` - Standard (non-TDD) planning
-- `/workflow:execute` - Execute TDD tasks
-- `/workflow:tdd-verify` - Verify TDD compliance
-- `/workflow:status` - View progress
 ## TDD Workflow Enhancements
 
 ### Overview
@@ -294,7 +289,7 @@ IMPL (Green phase) tasks now include automatic test-fix cycle for resilient impl
 ```
 1. Write minimal implementation code
 2. Execute test suite
-3. IF tests pass → Complete task ✅
+3. IF tests pass → Complete task
 4. IF tests fail → Enter fix cycle:
    a. Gemini diagnoses with bug-fix template
    b. Apply fix (manual or Codex)
@@ -304,10 +299,10 @@ IMPL (Green phase) tasks now include automatic test-fix cycle for resilient impl
 ```
 
 **Benefits**:
-- ✅ Faster feedback within Green phase
-- ✅ Autonomous recovery from implementation errors
-- ✅ Systematic debugging with Gemini
-- ✅ Safe rollback prevents broken state
+- Faster feedback within Green phase
+- Autonomous recovery from implementation errors
+- Systematic debugging with Gemini
+- Safe rollback prevents broken state
 
 #### 3. Agent-Driven Planning
 **From plan --agent workflow**
@@ -335,7 +330,7 @@ Supports action-planning-agent for more autonomous TDD planning with:
 
 ### Migration Notes
 
-**Backward Compatibility**: ✅ Fully compatible
+**Backward Compatibility**: Fully compatible
 - Existing TDD workflows continue to work
 - New features are additive, not breaking
 - Phase 3 can be skipped if test-context-gather not available
@@ -367,3 +362,23 @@ Supports action-planning-agent for more autonomous TDD planning with:
 - `meta.max_iterations`: Fix attempts (default: 3)
 - `meta.use_codex`: Auto-fix mode (default: false)
 
+## Related Commands
+
+**Prerequisite Commands**:
+- None - TDD planning is self-contained (can optionally run brainstorm commands before)
+
+**Called by This Command** (6 phases):
+- `/workflow:session:start` - Phase 1: Create or discover TDD workflow session
+- `/workflow:tools:context-gather` - Phase 2: Gather project context and analyze codebase
+- `/workflow:tools:test-context-gather` - Phase 3: Analyze existing test patterns and coverage
+- `/workflow:tools:conflict-resolution` - Phase 4: Detect and resolve conflicts (auto-triggered if conflict_risk ≥ medium)
+- `/compact` - Phase 4: Memory optimization (if context approaching limits)
+- `/workflow:tools:task-generate-tdd` - Phase 5: Generate TDD task chains with Red-Green-Refactor cycles
+- `/workflow:tools:task-generate-tdd --agent` - Phase 5: Generate TDD tasks with agent-driven approach (when `--agent` flag used)
+
+**Follow-up Commands**:
+- `/workflow:action-plan-verify` - Recommended: Verify TDD plan quality and structure before execution
+- `/workflow:status` - Review TDD task breakdown
+- `/workflow:execute` - Begin TDD implementation
+- `/workflow:tdd-verify` - Post-execution: Verify TDD compliance and generate quality report
+

.claude/commands/workflow/tdd-verify.md

@@ -1,6 +1,6 @@
 ---
 name: tdd-verify
-description: Verify TDD workflow compliance and generate quality report
+description: Verify TDD workflow compliance against Red-Green-Refactor cycles, generate quality report with coverage analysis
 
 argument-hint: "[optional: WFS-session-id]"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(gemini:*)
@@ -118,14 +118,14 @@ RULES: Focus on TDD best practices and workflow adherence. Be specific about vio
 TDD Verification Report - Session: {sessionId}
 
 ## Chain Validation
-✅ Feature 1: TEST-1.1 → IMPL-1.1 → REFACTOR-1.1 (Complete)
-✅ Feature 2: TEST-2.1 → IMPL-2.1 → REFACTOR-2.1 (Complete)
-⚠️  Feature 3: TEST-3.1 → IMPL-3.1 (Missing REFACTOR phase)
+[COMPLETE] Feature 1: TEST-1.1 → IMPL-1.1 → REFACTOR-1.1 (Complete)
+[COMPLETE] Feature 2: TEST-2.1 → IMPL-2.1 → REFACTOR-2.1 (Complete)
+[INCOMPLETE] Feature 3: TEST-3.1 → IMPL-3.1 (Missing REFACTOR phase)
 
 ## Test Execution
-✅ All TEST tasks produced failing tests
-✅ All IMPL tasks made tests pass
-✅ All REFACTOR tasks maintained green tests
+All TEST tasks produced failing tests
+All IMPL tasks made tests pass
+All REFACTOR tasks maintained green tests
 
 ## Coverage Metrics
 Line Coverage: {percentage}%
@@ -271,20 +271,20 @@ Status: {EXCELLENT | GOOD | NEEDS IMPROVEMENT | FAILED}
 ## Chain Analysis
 
 ### Feature 1: {Feature Name}
-**Status**: ✅ Complete
+**Status**: Complete
 **Chain**: TEST-1.1 → IMPL-1.1 → REFACTOR-1.1
 
-- ✅ **Red Phase**: Test created and failed with clear message
-- ✅ **Green Phase**: Minimal implementation made test pass
-- ✅ **Refactor Phase**: Code improved, tests remained green
+- **Red Phase**: Test created and failed with clear message
+- **Green Phase**: Minimal implementation made test pass
+- **Refactor Phase**: Code improved, tests remained green
 
 ### Feature 2: {Feature Name}
-**Status**: ⚠️ Incomplete
+**Status**: Incomplete
 **Chain**: TEST-2.1 → IMPL-2.1 (Missing REFACTOR-2.1)
 
-- ✅ **Red Phase**: Test created and failed
-- ⚠️ **Green Phase**: Implementation seems over-engineered
-- ❌ **Refactor Phase**: Missing
+- **Red Phase**: Test created and failed
+- **Green Phase**: Implementation seems over-engineered
+- **Refactor Phase**: Missing
 
 **Issues**:
 - REFACTOR-2.1 task not completed
@@ -306,16 +306,16 @@ Status: {EXCELLENT | GOOD | NEEDS IMPROVEMENT | FAILED}
 ## TDD Cycle Validation
 
 ### Red Phase (Write Failing Test)
-- ✅ {N}/{total} features had failing tests initially
-- ⚠️ Feature 3: No evidence of initial test failure
+- {N}/{total} features had failing tests initially
+- Feature 3: No evidence of initial test failure
 
 ### Green Phase (Make Test Pass)
-- ✅ {N}/{total} implementations made tests pass
-- ✅ All implementations minimal and focused
+- {N}/{total} implementations made tests pass
+- All implementations minimal and focused
 
 ### Refactor Phase (Improve Quality)
-- ⚠️ {N}/{total} features completed refactoring
-- ❌ Feature 2, 4: Refactoring step skipped
+- {N}/{total} features completed refactoring
+- Feature 2, 4: Refactoring step skipped
 
 ## Best Practices Assessment
 
@@ -351,8 +351,3 @@ Status: {EXCELLENT | GOOD | NEEDS IMPROVEMENT | FAILED}
 {Summary of compliance status and next steps}
 ```
 
-## Related Commands
-- `/workflow:tdd-plan` - Creates TDD workflow
-- `/workflow:execute` - Executes TDD tasks
-- `/workflow:tools:tdd-coverage-analysis` - Analyzes test coverage
-- `/workflow:status` - Views workflow progress

.claude/commands/workflow/test-cycle-execute.md

@@ -1,6 +1,6 @@
 ---
 name: test-cycle-execute
-description: Execute test-fix workflow with dynamic task generation and iterative fix cycles
+description: Execute test-fix workflow with dynamic task generation and iterative fix cycles until all tests pass or max iterations reached
 argument-hint: "[--resume-session=\"session-id\"] [--max-iterations=N]"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*)
 ---
@@ -10,7 +10,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*)
 ## Overview
 Orchestrates dynamic test-fix workflow execution through iterative cycles of testing, analysis, and fixing. **Unlike standard execute, this command dynamically generates intermediate tasks** during execution based on test results and CLI analysis, enabling adaptive problem-solving.
 
-**⚠️ CRITICAL - Orchestrator Boundary**:
+**CRITICAL - Orchestrator Boundary**:
 - This command is the **ONLY place** where test failures are handled
 - All CLI analysis (Gemini/Qwen), fix task generation (IMPL-fix-N.json), and iteration management happen HERE
 - Agents (@test-fix-agent) only execute single tasks and return results
@@ -59,22 +59,22 @@ Orchestrates dynamic test-fix workflow execution through iterative cycles of tes
 
 ## Responsibility Matrix
 
-**⚠️ CRITICAL - Clear division of labor between orchestrator and agents:**
+**CRITICAL - Clear division of labor between orchestrator and agents:**
 
 | Responsibility | test-cycle-execute (Orchestrator) | @test-fix-agent (Executor) |
 |----------------|----------------------------|---------------------------|
-| Manage iteration loop | ✅ Controls loop flow | ❌ Executes single task |
-| Run CLI analysis (Gemini/Qwen) | ✅ Runs between agent tasks | ❌ Not involved |
-| Generate IMPL-fix-N.json | ✅ Creates task files | ❌ Not involved |
-| Run tests | ❌ Delegates to agent | ✅ Executes test command |
-| Apply fixes | ❌ Delegates to agent | ✅ Modifies code |
-| Detect test failures | ✅ Analyzes results and decides next action | ✅ Executes tests and reports outcomes |
-| Add tasks to queue | ✅ Manages queue | ❌ Not involved |
-| Update iteration state | ✅ Maintains overall iteration state | ✅ Updates individual task status only |
+| Manage iteration loop | Yes - Controls loop flow | No - Executes single task |
+| Run CLI analysis (Gemini/Qwen) | Yes - Runs between agent tasks | No - Not involved |
+| Generate IMPL-fix-N.json | Yes - Creates task files | No - Not involved |
+| Run tests | No - Delegates to agent | Yes - Executes test command |
+| Apply fixes | No - Delegates to agent | Yes - Modifies code |
+| Detect test failures | Yes - Analyzes results and decides next action | Yes - Executes tests and reports outcomes |
+| Add tasks to queue | Yes - Manages queue | No - Not involved |
+| Update iteration state | Yes - Maintains overall iteration state | Yes - Updates individual task status only |
 
 **Key Principle**: Orchestrator manages the "what" and "when"; agents execute the "how".
 
-**⚠️ ENFORCEMENT**: If test failures occur outside this orchestrator, do NOT handle them inline - always call `/workflow:test-cycle-execute` instead.
+**ENFORCEMENT**: If test failures occur outside this orchestrator, do NOT handle them inline - always call `/workflow:test-cycle-execute` instead.
 
 ## Execution Lifecycle
 
@@ -653,10 +653,3 @@ mv temp.json iteration-state.json
 5. **Verify No Regressions**: Check all tests pass, not just previously failing ones
 6. **Preserve Context**: All iteration artifacts saved for debugging
 
-## Related Commands
-
-- `/workflow:test-fix-gen` - Planning phase (creates initial tasks)
-- `/workflow:execute` - Standard workflow execution (no dynamic iteration)
-- `/workflow:status` - Check progress and iteration state
-- `/workflow:session:complete` - Mark session complete (auto-called on success)
-- `/task:create` - Manually create additional tasks if needed

.claude/commands/workflow/test-fix-gen.md

@@ -1,6 +1,6 @@
 ---
 name: test-fix-gen
-description: Create independent test-fix workflow session from existing implementation (session or prompt-based)
+description: Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning
 argument-hint: "[--use-codex] [--cli-execute] (source-session-id | \"feature description\" | /path/to/file.md)"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
@@ -13,7 +13,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 This command creates an independent test-fix workflow session for existing code. It orchestrates a 5-phase process to analyze implementation, generate test requirements, and create executable test generation and fix tasks.
 
-**⚠️ CRITICAL - Command Scope**:
+**CRITICAL - Command Scope**:
 - **This command ONLY generates task JSON files** (IMPL-001.json, IMPL-002.json)
 - **Does NOT execute tests or apply fixes** - all execution happens in separate orchestrator
 - **Must call `/workflow:test-cycle-execute`** after this command to actually run tests and fixes
@@ -274,7 +274,7 @@ Review artifacts:
 - Test plan: .workflow/[testSessionId]/IMPL_PLAN.md
 - Task list: .workflow/[testSessionId]/TODO_LIST.md
 
-⚠️ CRITICAL - Next Steps:
+CRITICAL - Next Steps:
 1. Review IMPL_PLAN.md
 2. **MUST execute: /workflow:test-cycle-execute**
    - This command only generated task JSON files
@@ -284,7 +284,7 @@ Review artifacts:
 
 **TodoWrite**: Mark phase 5 completed
 
-**⚠️ BOUNDARY NOTE**:
+**BOUNDARY NOTE**:
 - Command completes here - only task JSON files generated
 - All test execution, failure detection, CLI analysis, fix generation happens in `/workflow:test-cycle-execute`
 - This command does NOT handle test failures or apply fixes
@@ -462,25 +462,23 @@ WFS-test-[session]/
    - Use `--use-codex` for autonomous fix application
    - Use `--cli-execute` for enhanced generation capabilities
 
-### Related Commands
+## Related Commands
 
-**Planning Phase**:
-- `/workflow:plan` - Create implementation workflow
-- `/workflow:session:start` - Initialize workflow session
+**Prerequisite Commands**:
+- `/workflow:plan` or `/workflow:execute` - Complete implementation session (for Session Mode)
+- None for Prompt Mode (ad-hoc test generation)
 
-**Context Gathering**:
-- `/workflow:tools:test-context-gather` - Session-based context (Phase 2 for session mode)
-- `/workflow:tools:context-gather` - Prompt-based context (Phase 2 for prompt mode)
+**Called by This Command** (5 phases):
+- `/workflow:session:start` - Phase 1: Create independent test workflow session
+- `/workflow:tools:test-context-gather` - Phase 2 (Session Mode): Gather source session context
+- `/workflow:tools:context-gather` - Phase 2 (Prompt Mode): Analyze codebase directly
+- `/workflow:tools:test-concept-enhanced` - Phase 3: Generate test requirements using Gemini
+- `/workflow:tools:test-task-generate` - Phase 4: Generate test task JSONs with fix cycle specification
+- `/workflow:tools:test-task-generate --use-codex` - Phase 4: With automated Codex fixes (when `--use-codex` flag used)
+- `/workflow:tools:test-task-generate --cli-execute` - Phase 4: With CLI execution mode (when `--cli-execute` flag used)
 
-**Analysis & Task Generation**:
-- `/workflow:tools:test-concept-enhanced` - Gemini test analysis (Phase 3)
-- `/workflow:tools:test-task-generate` - Generate test tasks (Phase 4)
+**Follow-up Commands**:
+- `/workflow:status` - Review generated test tasks
+- `/workflow:test-cycle-execute` - Execute test generation and iterative fix cycles
+- `/workflow:execute` - Standard execution of generated test tasks
 
-**Execution**:
-- `/workflow:test-cycle-execute` - Execute test-fix workflow (recommended for IMPL-002)
-- `/workflow:execute` - Execute standard workflow tasks
-- `/workflow:status` - Check task progress
-
-**Review & Management**:
-- `/workflow:review` - Review workflow results
-- `/workflow:session:complete` - Mark session complete

.claude/commands/workflow/test-gen.md

@@ -1,6 +1,6 @@
 ---
 name: test-gen
-description: Create independent test-fix workflow session by analyzing completed implementation
+description: Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks
 argument-hint: "[--use-codex] [--cli-execute] source-session-id"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
@@ -24,7 +24,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 3. Analyze implementation with concept-enhanced → Parse ANALYSIS_RESULTS.md
 4. Generate test task from analysis → Return summary
 
-**⚠️ Command Scope**: This command ONLY prepares test workflow artifacts. It does NOT execute tests or implementation. Task execution requires separate user action.
+**Command Scope**: This command ONLY prepares test workflow artifacts. It does NOT execute tests or implementation. Task execution requires separate user action.
 
 ## Core Rules
 
@@ -36,7 +36,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 6. **Track Progress**: Update TodoWrite after every phase completion
 7. **Automatic Detection**: context-gather auto-detects test session and gathers source session context
 8. **Parse --use-codex Flag**: Extract flag from arguments and pass to Phase 4 (test-task-generate)
-9. **⚠️ Command Boundary**: This command ends at Phase 5 summary. Test execution is NOT part of this command.
+9. **Command Boundary**: This command ends at Phase 5 summary. Test execution is NOT part of this command.
 
 ## 5-Phase Execution
 
@@ -177,13 +177,13 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 ---
 
-### Phase 5: Return Summary (⚠️ Command Ends Here)
+### Phase 5: Return Summary (Command Ends Here)
 
-**⚠️ Important**: This is the final phase of `/workflow:test-gen`. The command completes and returns control to the user. No automatic execution occurs.
+**Important**: This is the final phase of `/workflow:test-gen`. The command completes and returns control to the user. No automatic execution occurs.
 
 **Return to User**:
 ```
-✅ Test workflow preparation complete!
+Test workflow preparation complete!
 
 Source Session: [sourceSessionId]
 Test Session: [testSessionId]
@@ -198,17 +198,17 @@ Test Framework: [detected framework]
 Test Files to Generate: [count]
 Fix Mode: [Manual|Codex Automated] (based on --use-codex flag)
 
-📋 Review Generated Artifacts:
+Review Generated Artifacts:
 - Test plan: .workflow/[testSessionId]/IMPL_PLAN.md
 - Task list: .workflow/[testSessionId]/TODO_LIST.md
 - Analysis: .workflow/[testSessionId]/.process/TEST_ANALYSIS_RESULTS.md
 
-⚠️ Ready for execution. Use appropriate workflow commands to proceed.
+Ready for execution. Use appropriate workflow commands to proceed.
 ```
 
 **TodoWrite**: Mark phase 5 completed
 
-**⚠️ Command Boundary**: After this phase, the command terminates and returns to user prompt.
+**Command Boundary**: After this phase, the command terminates and returns to user prompt.
 
 ---
 
@@ -244,7 +244,7 @@ Update status to `in_progress` when starting each phase, mark `completed` when d
 │   ↓                                                     │
 │ Phase 5: Return summary                                │
 └─────────────────────────────────────────────────────────┘
-         ⚠️ COMMAND ENDS - Control returns to user
+         COMMAND ENDS - Control returns to user
 
 Artifacts Created:
 ├── .workflow/WFS-test-[session]/
@@ -330,8 +330,18 @@ See `/workflow:tools:test-task-generate` for complete JSON schemas.
 
 ## Related Commands
 
-- `/workflow:tools:test-context-gather` - Phase 2 (coverage analysis)
-- `/workflow:tools:test-concept-enhanced` - Phase 3 (Gemini test analysis)
-- `/workflow:tools:test-task-generate` - Phase 4 (task generation)
-- `/workflow:execute` - Execute workflow
-- `/workflow:status` - Check progress
+**Prerequisite Commands**:
+- `/workflow:plan` or `/workflow:execute` - Complete implementation session that needs test validation
+
+**Called by This Command** (5 phases):
+- `/workflow:session:start` - Phase 1: Create independent test workflow session
+- `/workflow:tools:test-context-gather` - Phase 2: Analyze test coverage and gather source session context
+- `/workflow:tools:test-concept-enhanced` - Phase 3: Generate test requirements and strategy using Gemini
+- `/workflow:tools:test-task-generate` - Phase 4: Generate test generation and execution task JSONs
+- `/workflow:tools:test-task-generate --use-codex` - Phase 4: With automated Codex fixes (when `--use-codex` flag used)
+- `/workflow:tools:test-task-generate --cli-execute` - Phase 4: With CLI execution mode (when `--cli-execute` flag used)
+
+**Follow-up Commands**:
+- `/workflow:status` - Review generated test tasks
+- `/workflow:test-cycle-execute` - Execute test generation and fix cycles
+- `/workflow:execute` - Execute generated test tasks

.claude/commands/workflow/tools/conflict-resolution.md

@@ -1,6 +1,6 @@
 ---
 name: conflict-resolution
-description: Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis
+description: Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen
 argument-hint: "--session WFS-session-id --context path/to/context-package.json"
 examples:
   - /workflow:tools:conflict-resolution --session WFS-auth --context .workflow/WFS-auth/.process/context-package.json

.claude/commands/workflow/tools/context-gather.md

@@ -1,6 +1,6 @@
 ---
 name: gather
-description: Intelligently collect project context using context-search-agent based on task description and package into standardized JSON
+description: Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON
 argument-hint: "--session WFS-session-id \"task description\""
 examples:
   - /workflow:tools:context-gather --session WFS-user-auth "Implement user authentication system"
@@ -76,17 +76,19 @@ Execute complete context-search-agent workflow for implementation planning:
 3. **Analysis**: Extract keywords, determine scope, classify complexity
 
 ### Phase 2: Multi-Source Context Discovery
-Execute all 3 discovery tracks:
-- **Track 1**: Reference documentation (CLAUDE.md, architecture docs)
-- **Track 2**: Web examples (use Exa MCP for unfamiliar tech/APIs)
-- **Track 3**: Codebase analysis (5-layer discovery: files, content, patterns, deps, config/tests)
+Execute all 4 discovery tracks:
+- **Track 1**: Historical archive analysis (query manifest.json for lessons learned)
+- **Track 2**: Reference documentation (CLAUDE.md, architecture docs)
+- **Track 3**: Web examples (use Exa MCP for unfamiliar tech/APIs)
+- **Track 4**: Codebase analysis (5-layer discovery: files, content, patterns, deps, config/tests)
 
 ### Phase 3: Synthesis, Assessment & Packaging
 1. Apply relevance scoring and build dependency graph
-2. Synthesize 3-source data (docs > code > web)
+2. Synthesize 4-source data (archive > docs > code > web)
 3. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
 4. Perform conflict detection with risk assessment
-5. Generate and validate context-package.json
+5. **Inject historical conflicts** from archive analysis into conflict_detection
+6. Generate and validate context-package.json
 
 ## Output Requirements
 Complete context-package.json with:
@@ -95,7 +97,7 @@ Complete context-package.json with:
 - **assets**: {documentation[], source_code[], config[], tests[]} with relevance scores
 - **dependencies**: {internal[], external[]} with dependency graph
 - **brainstorm_artifacts**: {guidance_specification, role_analyses[], synthesis_output} with content
-- **conflict_detection**: {risk_level, risk_factors, affected_modules[], mitigation_strategy}
+- **conflict_detection**: {risk_level, risk_factors, affected_modules[], mitigation_strategy, historical_conflicts[]}
 
 ## Quality Validation
 Before completion verify:
@@ -141,7 +143,112 @@ Refer to `context-search-agent.md` Phase 3.7 for complete `context-package.json`
 - **assets**: Categorized files with relevance scores (documentation, source_code, config, tests)
 - **dependencies**: Internal and external dependency graphs
 - **brainstorm_artifacts**: Brainstorm documents with full content (if exists)
-- **conflict_detection**: Risk assessment with mitigation strategies
+- **conflict_detection**: Risk assessment with mitigation strategies and historical conflicts
+
+## Historical Archive Analysis
+
+### Track 1: Query Archive Manifest
+
+The context-search-agent MUST perform historical archive analysis as Track 1 in Phase 2:
+
+**Step 1: Check for Archive Manifest**
+```bash
+# Check if archive manifest exists
+if [[ -f .workflow/.archives/manifest.json ]]; then
+  # Manifest available for querying
+fi
+```
+
+**Step 2: Extract Task Keywords**
+```javascript
+// From current task description, extract key entities and operations
+const keywords = extractKeywords(task_description);
+// Examples: ["User", "model", "authentication", "JWT", "reporting"]
+```
+
+**Step 3: Search Archive for Relevant Sessions**
+```javascript
+// Query manifest for sessions with matching tags or descriptions
+const relevantArchives = archives.filter(archive => {
+  return archive.tags.some(tag => keywords.includes(tag)) ||
+         keywords.some(kw => archive.description.toLowerCase().includes(kw.toLowerCase()));
+});
+```
+
+**Step 4: Extract Watch Patterns**
+```javascript
+// For each relevant archive, check watch_patterns for applicability
+const historicalConflicts = [];
+
+relevantArchives.forEach(archive => {
+  archive.lessons.watch_patterns?.forEach(pattern => {
+    // Check if pattern trigger matches current task
+    if (isPatternRelevant(pattern.pattern, task_description)) {
+      historicalConflicts.push({
+        source_session: archive.session_id,
+        pattern: pattern.pattern,
+        action: pattern.action,
+        files_to_check: pattern.related_files,
+        archived_at: archive.archived_at
+      });
+    }
+  });
+});
+```
+
+**Step 5: Inject into Context Package**
+```json
+{
+  "conflict_detection": {
+    "risk_level": "medium",
+    "risk_factors": ["..."],
+    "affected_modules": ["..."],
+    "mitigation_strategy": "...",
+    "historical_conflicts": [
+      {
+        "source_session": "WFS-auth-feature",
+        "pattern": "When modifying User model",
+        "action": "Check reporting-service and auditing-service dependencies",
+        "files_to_check": ["src/models/User.ts", "src/services/reporting.ts"],
+        "archived_at": "2025-09-16T09:00:00Z"
+      }
+    ]
+  }
+}
+```
+
+### Risk Level Escalation
+
+If `historical_conflicts` array is not empty, minimum risk level should be "medium":
+
+```javascript
+if (historicalConflicts.length > 0 && currentRisk === "low") {
+  conflict_detection.risk_level = "medium";
+  conflict_detection.risk_factors.push(
+    `${historicalConflicts.length} historical conflict pattern(s) detected from past sessions`
+  );
+}
+```
+
+### Archive Query Algorithm
+
+```markdown
+1. IF .workflow/.archives/manifest.json does NOT exist → Skip Track 1, continue to Track 2
+2. IF manifest exists:
+   a. Load manifest.json
+   b. Extract keywords from task_description (nouns, verbs, technical terms)
+   c. Filter archives where:
+      - ANY tag matches keywords (case-insensitive) OR
+      - description contains keywords (case-insensitive substring match)
+   d. For each relevant archive:
+      - Read lessons.watch_patterns array
+      - Check if pattern.pattern keywords overlap with task_description
+      - If relevant: Add to historical_conflicts array
+   e. IF historical_conflicts.length > 0:
+      - Set risk_level = max(current_risk, "medium")
+      - Add to risk_factors
+3. Continue to Track 2 (reference documentation)
+```
 
 ## Usage Examples
 

.claude/commands/workflow/tools/task-generate-agent.md

@@ -1,6 +1,6 @@
 ---
 name: task-generate-agent
-description: Autonomous task generation using action-planning-agent with discovery and output phases
+description: Autonomous task generation using action-planning-agent with discovery and output phases for workflow planning
 argument-hint: "--session WFS-session-id [--cli-execute]"
 examples:
   - /workflow:tools:task-generate-agent --session WFS-auth
@@ -19,6 +19,7 @@ Autonomous task JSON and IMPL_PLAN.md generation using action-planning-agent wit
 - **MCP-Enhanced**: Use MCP tools for advanced code analysis and research
 - **Pre-Selected Templates**: Command selects correct template based on `--cli-execute` flag **before** invoking agent
 - **Agent Simplicity**: Agent receives pre-selected template and focuses only on content generation
+- **Path Clarity**: All `focus_paths` prefer absolute paths (e.g., `D:\\project\\src\\module`), or clear relative paths from project root (e.g., `./src/module`)
 
 ## Execution Lifecycle
 

.claude/commands/workflow/tools/task-generate-tdd.md

@@ -1,6 +1,6 @@
 ---
 name: task-generate-tdd
-description: Generate TDD task chains with Red-Green-Refactor dependencies
+description: Generate TDD task chains with Red-Green-Refactor dependencies, test-first structure, and cycle validation
 argument-hint: "--session WFS-session-id [--agent]"
 allowed-tools: Read(*), Write(*), Bash(gemini:*), TodoWrite(*)
 ---
@@ -49,6 +49,7 @@ Generate TDD-specific tasks from analysis results with complete Red-Green-Refact
 - **Feature-Complete Tasks**: Each task contains complete Red-Green-Refactor cycle
 - **Phase-Explicit**: Internal phases clearly marked in flow_control.implementation_approach
 - **Task Merging**: Prefer single task per feature over decomposition
+- **Path Clarity**: All `focus_paths` prefer absolute paths (e.g., `D:\\project\\src\\module`), or clear relative paths from project root (e.g., `./src/module`)
 - **Artifact-Aware**: Integrates brainstorming outputs
 - **Memory-First**: Reuse loaded documents from memory
 - **Context-Aware**: Analyzes existing codebase and test patterns
@@ -157,7 +158,7 @@ For each feature, generate task(s) with ID format:
         "expected_failure": "Why test should fail initially"
       }
     ],
-    "focus_paths": ["src/path/", "tests/path/"],  // Files to modify
+    "focus_paths": ["D:\\project\\src\\path", "./tests/path"],  // Absolute or clear relative paths from project root
     "acceptance": [                                // Success criteria
       "All tests pass (Red → Green)",
       "Code refactored (Refactor complete)",

.claude/commands/workflow/tools/task-generate.md

@@ -1,6 +1,6 @@
 --- 
 name: task-generate
-description: Generate task JSON files and IMPL_PLAN.md from analysis results with artifacts integration
+description: Generate task JSON files and IMPL_PLAN.md from analysis results using action-planning-agent with artifact integration
 argument-hint: "--session WFS-session-id [--cli-execute]"
 examples:
   - /workflow:tools:task-generate --session WFS-auth
@@ -40,6 +40,7 @@ This command is built on a set of core principles to ensure efficient and reliab
 - **Role Analysis-Driven**: All generated tasks originate from role-specific `analysis.md` files (enhanced in synthesis phase), ensuring direct link between requirements/design and implementation
 - **Artifact-Aware**: Automatically detects and integrates all brainstorming outputs (role analyses, guidance-specification.md, enhancements) to enrich task context
 - **Context-Rich**: Embeds comprehensive context (requirements, focus paths, acceptance criteria, artifact references) directly into each task JSON
+- **Path Clarity**: All `focus_paths` prefer absolute paths (e.g., `D:\\project\\src\\module`), or clear relative paths from project root (e.g., `./src/module`)
 - **Flow-Control Ready**: Pre-defines clear execution sequence (`pre_analysis`, `implementation_approach`) within each task
 - **Memory-First**: Prioritizes using documents already loaded in conversation memory to avoid redundant file operations
 - **Mode-Flexible**: Supports both agent-driven execution (default) and CLI tool execution (with `--cli-execute` flag)
@@ -182,7 +183,7 @@ This enhanced 5-field schema embeds all necessary context, artifacts, and execut
   },
   "context": {
     "requirements": ["Clear requirement from analysis"],
-    "focus_paths": ["src/module/path", "tests/module/path"],
+    "focus_paths": ["D:\\project\\src\\module\\path", "./tests/module/path"],
     "acceptance": ["Measurable acceptance criterion"],
     "parent": "IMPL-N",
     "depends_on": ["IMPL-N.M"],

.claude/commands/workflow/tools/tdd-coverage-analysis.md

@@ -1,6 +1,6 @@
 ---
 name: tdd-coverage-analysis
-description: Analyze test coverage and TDD cycle execution
+description: Analyze test coverage and TDD cycle execution with Red-Green-Refactor compliance verification
 argument-hint: "--session WFS-session-id"
 allowed-tools: Read(*), Write(*), Bash(*)
 ---

.claude/commands/workflow/tools/test-concept-enhanced.md

@@ -1,6 +1,6 @@
 ---
 name: test-concept-enhanced
-description: Analyze test requirements and generate test generation strategy using Gemini
+description: Analyze test requirements and generate test generation strategy using Gemini with test-context package
 argument-hint: "--session WFS-test-session-id --context path/to/test-context-package.json"
 examples:
   - /workflow:tools:test-concept-enhanced --session WFS-test-auth --context .workflow/WFS-test-auth/.process/test-context-package.json

.claude/commands/workflow/tools/test-context-gather.md

@@ -1,265 +1,188 @@
 ---
 name: test-context-gather
-description: Collect test coverage context and identify files requiring test generation
+description: Collect test coverage context using test-context-search-agent and package into standardized test-context JSON
 argument-hint: "--session WFS-test-session-id"
 examples:
   - /workflow:tools:test-context-gather --session WFS-test-auth
   - /workflow:tools:test-context-gather --session WFS-test-payment
+allowed-tools: Task(*), Read(*), Glob(*)
 ---
 
-# Test Context Gather Command
+# Test Context Gather Command (/workflow:tools:test-context-gather)
 
 ## Overview
-Specialized context collector for test generation workflows that analyzes test coverage, identifies missing tests, and packages implementation context from source sessions.
+
+Orchestrator command that invokes `test-context-search-agent` to gather comprehensive test coverage context for test generation workflows. Generates standardized `test-context-package.json` with coverage analysis, framework detection, and source implementation context.
+
+**Agent**: `test-context-search-agent` (`.claude/agents/test-context-search-agent.md`)
 
 ## Core Philosophy
-- **Coverage-First**: Analyze existing test coverage before planning
-- **Gap Identification**: Locate implementation files without corresponding tests
+
+- **Agent Delegation**: Delegate all test coverage analysis to `test-context-search-agent` for autonomous execution
+- **Detection-First**: Check for existing test-context-package before executing
+- **Coverage-First**: Analyze existing test coverage before planning new tests
 - **Source Context Loading**: Import implementation summaries from source session
-- **Framework Detection**: Auto-detect test framework and patterns
-- **Ripgrep-Powered**: Leverage ripgrep and native tools for precise analysis
+- **Standardized Output**: Generate `.workflow/{test_session_id}/.process/test-context-package.json`
 
-## Core Responsibilities
-- Load source session implementation context
-- Analyze current test coverage using ripgrep
-- Identify files requiring test generation
-- Detect test framework and conventions
-- Package test context for analysis phase
+## Execution Flow
 
-## Execution Lifecycle
+### Step 1: Test-Context-Package Detection
 
-### Phase 1: Session Validation & Source Loading
+**Execute First** - Check if valid package already exists:
 
-1. **Test Session Validation**
-   - Load `.workflow/{test_session_id}/workflow-session.json`
-   - Extract `meta.source_session` reference
-   - Validate test session type is "test-gen"
+```javascript
+const testContextPath = `.workflow/${test_session_id}/.process/test-context-package.json`;
 
-2. **Source Session Context Loading**
-   - Read `.workflow/{source_session_id}/workflow-session.json`
-   - Load implementation summaries from `.workflow/{source_session_id}/.summaries/`
-   - Extract changed files and implementation scope
-   - Identify implementation patterns and tech stack
+if (file_exists(testContextPath)) {
+  const existing = Read(testContextPath);
 
-### Phase 2: Test Coverage Analysis (Ripgrep)
-
-1. **Existing Test Discovery**
-   ```bash
-   # Find all test files
-   find . -name "*.test.*" -type f
-   find . -name "*.spec.*" -type f
-   find . -name "*test_*.py" -type f
-
-   # Search for test patterns
-   rg "describe|it|test|@Test" -g "*.test.*"
-   ```
-
-2. **Coverage Gap Analysis**
-   ```bash
-   # For each implementation file from source session
-   # Check if corresponding test file exists
-
-   # Example: src/auth/AuthService.ts -> tests/auth/AuthService.test.ts
-   #          src/utils/validator.py -> tests/test_validator.py
-
-   # Output: List of files without tests
-   ```
-
-3. **Test Statistics**
-   - Count total test files
-   - Count implementation files from source session
-   - Calculate coverage percentage
-   - Identify coverage gaps by module
-
-### Phase 3: Test Framework Detection
-
-1. **Framework Identification**
-   ```bash
-   # Check package.json or requirements.txt
-   rg "jest|mocha|jasmine|pytest|unittest|rspec" -g "package.json" -g "requirements.txt" -g "Gemfile" -C 2
-
-   # Analyze existing test patterns
-   rg "describe\(|it\(|test\(|def test_" -g "*.test.*" -C 3
-   ```
-
-2. **Convention Analysis**
-   - Test file naming patterns (*.test.ts vs *.spec.ts)
-   - Test directory structure (tests/ vs __tests__ vs src/**/*.test.*)
-   - Assertion library (expect, assert, should)
-   - Mocking framework (jest.fn, sinon, unittest.mock)
-
-### Phase 4: Context Packaging
-
-Generate `test-context-package.json`:
-
-```json
-{
-  "metadata": {
-    "test_session_id": "WFS-test-auth",
-    "source_session_id": "WFS-auth",
-    "timestamp": "2025-10-04T10:30:00Z",
-    "task_type": "test-generation",
-    "complexity": "medium"
-  },
-  "source_context": {
-    "implementation_summaries": [
-      {
-        "task_id": "IMPL-001",
-        "summary_path": ".workflow/WFS-auth/.summaries/IMPL-001-summary.md",
-        "changed_files": [
-          "src/auth/AuthService.ts",
-          "src/auth/TokenValidator.ts",
-          "src/middleware/auth.ts"
-        ],
-        "implementation_type": "feature"
-      }
-    ],
-    "tech_stack": ["typescript", "express", "jsonwebtoken"],
-    "project_patterns": {
-      "architecture": "layered",
-      "error_handling": "try-catch with custom errors",
-      "async_pattern": "async/await"
-    }
-  },
-  "test_coverage": {
-    "existing_tests": [
-      "tests/auth/AuthService.test.ts",
-      "tests/middleware/auth.test.ts"
-    ],
-    "missing_tests": [
-      {
-        "implementation_file": "src/auth/TokenValidator.ts",
-        "suggested_test_file": "tests/auth/TokenValidator.test.ts",
-        "priority": "high",
-        "reason": "New implementation without tests"
-      }
-    ],
-    "coverage_stats": {
-      "total_implementation_files": 3,
-      "files_with_tests": 2,
-      "files_without_tests": 1,
-      "coverage_percentage": 66.7
-    }
-  },
-  "test_framework": {
-    "framework": "jest",
-    "version": "^29.0.0",
-    "test_pattern": "**/*.test.ts",
-    "test_directory": "tests/",
-    "assertion_library": "expect",
-    "mocking_framework": "jest",
-    "conventions": {
-      "file_naming": "*.test.ts",
-      "test_structure": "describe/it blocks",
-      "setup_teardown": "beforeEach/afterEach"
-    }
-  },
-  "assets": [
-    {
-      "type": "implementation_summary",
-      "path": ".workflow/WFS-auth/.summaries/IMPL-001-summary.md",
-      "relevance": "Source implementation context",
-      "priority": "highest"
-    },
-    {
-      "type": "existing_test",
-      "path": "tests/auth/AuthService.test.ts",
-      "relevance": "Test pattern reference",
-      "priority": "high"
-    },
-    {
-      "type": "source_code",
-      "path": "src/auth/TokenValidator.ts",
-      "relevance": "Implementation requiring tests",
-      "priority": "high"
-    },
-    {
-      "type": "documentation",
-      "path": "CLAUDE.md",
-      "relevance": "Project conventions",
-      "priority": "medium"
-    }
-  ],
-  "focus_areas": [
-    "Generate comprehensive tests for TokenValidator",
-    "Follow existing Jest patterns from AuthService tests",
-    "Cover happy path, error cases, and edge cases",
-    "Include integration tests for middleware"
-  ]
+  // Validate package belongs to current test session
+  if (existing?.metadata?.test_session_id === test_session_id) {
+    console.log("✅ Valid test-context-package found for session:", test_session_id);
+    console.log("📊 Coverage Stats:", existing.test_coverage.coverage_stats);
+    console.log("🧪 Framework:", existing.test_framework.framework);
+    console.log("⚠️  Missing Tests:", existing.test_coverage.missing_tests.length);
+    return existing; // Skip execution, return existing
+  } else {
+    console.warn("⚠️ Invalid test_session_id in existing package, re-generating...");
+  }
 }
 ```
 
-## Output Location
+### Step 2: Invoke Test-Context-Search Agent
 
-```
-.workflow/{test_session_id}/.process/test-context-package.json
-```
+**Only execute if Step 1 finds no valid package**
 
-## Native Tools Usage
+```javascript
+Task(
+  subagent_type="test-context-search-agent",
+  description="Gather test coverage context",
+  prompt=`
+You are executing as test-context-search-agent (.claude/agents/test-context-search-agent.md).
 
-### File Discovery
-```bash
-# Test files
-find . -name "*.test.*" -type f
-find . -name "*.spec.*" -type f
+## Execution Mode
+**PLAN MODE** (Comprehensive) - Full Phase 1-3 execution
 
-# Implementation files
-find . -name "*.ts" -type f
-find . -name "*.js" -type f
-```
+## Session Information
+- **Test Session ID**: ${test_session_id}
+- **Output Path**: .workflow/${test_session_id}/.process/test-context-package.json
 
-### Content Search
-```bash
-# Test framework detection
-rg "jest|mocha|pytest" -g "package.json" -g "requirements.txt"
+## Mission
+Execute complete test-context-search-agent workflow for test generation planning:
 
-# Test pattern analysis
-rg "describe|it|test" -g "*.test.*" -C 2
-```
+### Phase 1: Session Validation & Source Context Loading
+1. **Detection**: Check for existing test-context-package (early exit if valid)
+2. **Test Session Validation**: Load test session metadata, extract source_session reference
+3. **Source Context Loading**: Load source session implementation summaries, changed files, tech stack
 
-### Coverage Analysis
-```bash
-# For each implementation file
-# Check if test exists
-implementation_file="src/auth/AuthService.ts"
-test_file_patterns=(
-  "tests/auth/AuthService.test.ts"
-  "src/auth/AuthService.test.ts"
-  "src/auth/__tests__/AuthService.test.ts"
+### Phase 2: Test Coverage Analysis
+Execute coverage discovery:
+- **Track 1**: Existing test discovery (find *.test.*, *.spec.* files)
+- **Track 2**: Coverage gap analysis (match implementation files to test files)
+- **Track 3**: Coverage statistics (calculate percentages, identify gaps by module)
+
+### Phase 3: Framework Detection & Packaging
+1. Framework identification from package.json/requirements.txt
+2. Convention analysis from existing test patterns
+3. Generate and validate test-context-package.json
+
+## Output Requirements
+Complete test-context-package.json with:
+- **metadata**: test_session_id, source_session_id, task_type, complexity
+- **source_context**: implementation_summaries, tech_stack, project_patterns
+- **test_coverage**: existing_tests[], missing_tests[], coverage_stats
+- **test_framework**: framework, version, test_pattern, conventions
+- **assets**: implementation_summary[], existing_test[], source_code[] with priorities
+- **focus_areas**: Test generation guidance based on coverage gaps
+
+## Quality Validation
+Before completion verify:
+- [ ] Valid JSON format with all required fields
+- [ ] Source session context loaded successfully
+- [ ] Test coverage gaps identified
+- [ ] Test framework detected (or marked as 'unknown')
+- [ ] Coverage percentage calculated correctly
+- [ ] Missing tests catalogued with priority
+- [ ] Execution time < 30 seconds (< 60s for large codebases)
+
+Execute autonomously following agent documentation.
+Report completion with coverage statistics.
+`
 )
-
-# Search for test file
-for pattern in "${test_file_patterns[@]}"; do
-  if [ -f "$pattern" ]; then
-    echo "✅ Test exists: $pattern"
-    break
-  fi
-done
 ```
 
+### Step 3: Output Verification
+
+After agent completes, verify output:
+
+```javascript
+// Verify file was created
+const outputPath = `.workflow/${test_session_id}/.process/test-context-package.json`;
+if (!file_exists(outputPath)) {
+  throw new Error("❌ Agent failed to generate test-context-package.json");
+}
+
+// Load and display summary
+const testContext = Read(outputPath);
+console.log("✅ Test context package generated successfully");
+console.log("📊 Coverage:", testContext.test_coverage.coverage_stats.coverage_percentage + "%");
+console.log("⚠️  Tests to generate:", testContext.test_coverage.missing_tests.length);
+```
+
+## Parameter Reference
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `--session` | string | ✅ | Test workflow session ID (e.g., WFS-test-auth) |
+
+## Output Schema
+
+Refer to `test-context-search-agent.md` Phase 3.2 for complete `test-context-package.json` schema.
+
+**Key Sections**:
+- **metadata**: Test session info, source session reference, complexity
+- **source_context**: Implementation summaries with changed files and tech stack
+- **test_coverage**: Existing tests, missing tests with priorities, coverage statistics
+- **test_framework**: Framework name, version, patterns, conventions
+- **assets**: Categorized files with relevance (implementation_summary, existing_test, source_code)
+- **focus_areas**: Test generation guidance based on analysis
+
+## Usage Examples
+
+### Basic Usage
+```bash
+/workflow:tools:test-context-gather --session WFS-test-auth
+```
+
+### Expected Output
+```
+✅ Valid test-context-package found for session: WFS-test-auth
+📊 Coverage Stats: { total: 3, with_tests: 2, without_tests: 1, percentage: 66.7 }
+🧪 Framework: jest
+⚠️  Missing Tests: 1
+```
+
+## Success Criteria
+
+- ✅ Valid test-context-package.json generated in `.workflow/{test_session_id}/.process/`
+- ✅ Source session context loaded successfully
+- ✅ Test coverage gaps identified (>90% accuracy)
+- ✅ Test framework detected and documented
+- ✅ Execution completes within 30 seconds (60s for large codebases)
+- ✅ All required schema fields present and valid
+- ✅ Coverage statistics calculated correctly
+- ✅ Agent reports completion with statistics
+
 ## Error Handling
 
 | Error | Cause | Resolution |
 |-------|-------|------------|
+| Package validation failed | Invalid test_session_id in existing package | Re-run agent to regenerate |
 | Source session not found | Invalid source_session reference | Verify test session metadata |
 | No implementation summaries | Source session incomplete | Complete source session first |
-| No test framework detected | Missing test dependencies | Request user to specify framework |
-
-## Native Tools Implementation
-
-```bash
-# File discovery
-find . -name "*.test.*" -o -name "*.spec.*" | grep -v node_modules
-
-# Framework detection
-grep -r "jest\|mocha\|pytest" package.json requirements.txt 2>/dev/null
-
-# Coverage analysis
-for impl_file in $(cat changed_files.txt); do
-  test_file=$(echo $impl_file | sed 's/src/tests/' | sed 's/\(.*\)\.\(ts\|js\|py\)$/\1.test.\2/')
-  [ ! -f "$test_file" ] && echo "$impl_file → MISSING TEST"
-done
-```
+| Agent execution timeout | Large codebase or slow analysis | Increase timeout, check file access |
+| Missing required fields | Agent incomplete execution | Check agent logs, verify schema compliance |
+| No test framework detected | Missing test dependencies | Agent marks as 'unknown', manual specification needed |
 
 ## Integration
 
@@ -267,20 +190,18 @@ done
 - `/workflow:test-gen` (Phase 3: Context Gathering)
 
 ### Calls
-- Ripgrep and find for file analysis
-- Bash file operations for coverage analysis
+- `test-context-search-agent` - Autonomous test coverage analysis
 
 ### Followed By
-- `/workflow:tools:test-concept-enhanced` - Analyzes context and plans test generation
+- `/workflow:tools:test-concept-enhanced` - Test generation analysis and planning
 
-## Success Criteria
+## Notes
 
-- ✅ Source session context loaded successfully
-- ✅ Test coverage gaps identified with ripgrep
-- ✅ Test framework detected and documented
-- ✅ Valid test-context-package.json generated
-- ✅ All missing tests catalogued with priority
-- ✅ Execution time < 20 seconds
+- **Detection-first**: Always check for existing test-context-package before invoking agent
+- **Agent autonomy**: Agent handles all coverage analysis logic per `.claude/agents/test-context-search-agent.md`
+- **No redundancy**: This command is a thin orchestrator, all logic in agent
+- **Framework agnostic**: Supports Jest, Mocha, pytest, RSpec, Go testing, etc.
+- **Coverage focus**: Primary goal is identifying implementation files without tests
 
 ## Related Commands
 

.claude/commands/workflow/tools/test-task-generate.md

@@ -1,6 +1,6 @@
 ---
 name: test-task-generate
-description: Generate test-fix task JSON with iterative test-fix-retest cycle specification
+description: Generate test-fix task JSON with iterative test-fix-retest cycle specification using Gemini/Qwen/Codex
 argument-hint: "[--use-codex] [--cli-execute] --session WFS-test-session-id"
 examples:
   - /workflow:tools:test-task-generate --session WFS-test-auth
@@ -363,7 +363,7 @@ Generate **TWO task JSON files**:
         "               Source files: [focus_paths]",
         "               Implementation: [implementation_context]",
         "      EXPECTED: Root cause analysis, code path tracing, targeted fixes",
-        "      RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: [test_failure_description]",
+        "      RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt) | Bug: [test_failure_description]",
         "             Minimal surgical fixes only - no refactoring",
         "      \" > fix-iteration-[N]-diagnosis.md)",
         "    - Parse diagnosis → extract fix_suggestion and target_files",
@@ -690,6 +690,6 @@ The `@test-fix-agent` will execute the task by following the `flow_control.imple
 6. **Phase 3**: Generate summary and certify code
 7. **Error Recovery**: Revert changes if max iterations reached
 
-**Bug Diagnosis Template**: Uses bug-fix.md template as referenced in bug-index.md for systematic root cause analysis, code path tracing, and targeted fix recommendations.
+**Bug Diagnosis Template**: Uses `~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt` template for systematic root cause analysis, code path tracing, and targeted fix recommendations.
 
 **Codex Usage**: The agent uses `codex exec "..." resume --last` pattern ONLY when meta.use_codex=true (--use-codex flag present) to maintain conversation context across multiple fix iterations, ensuring consistency and learning from previous attempts.

.claude/commands/workflow/ui-design/animation-extract.md

@@ -1,6 +1,6 @@
 ---
 name: animation-extract
-description: Extract animation and transition patterns from URLs, CSS, or interactive questioning
+description: Extract animation and transition patterns from URLs, CSS, or interactive questioning for design system documentation
 argument-hint: "[--base-path <path>] [--session <id>] [--urls "<list>"] [--mode <auto|interactive>] [--focus "<types>"]"
 allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), Bash(*), Task(ui-design-agent), mcp__chrome-devtools__navigate_page(*), mcp__chrome-devtools__evaluate_script(*)
 ---
@@ -170,128 +170,318 @@ ELSE:
     extraction_insufficient = true
 ```
 
-### Step 2: Interactive Question Workflow (Agent)
+### Step 2: Generate Animation Questions (Main Flow)
 
 ```bash
 # If extraction failed or insufficient, use interactive questioning
 IF extraction_insufficient OR extraction_mode == "interactive":
-    REPORT: "🤔 Launching interactive animation specification mode"
+    REPORT: "🤔 Interactive animation specification mode"
+    REPORT: "   Context: {has_design_context ? 'Aligning with design tokens' : 'Standalone animation system'}"
+    REPORT: "   Focus: {focus_types}"
 
-    # Launch ui-design-agent for interactive questioning
-    Task(ui-design-agent): `
-      [ANIMATION_SPECIFICATION_TASK]
-      Guide user through animation design decisions via structured questions
+    # Determine question categories based on focus_types
+    question_categories = []
+    IF "all" IN focus_types OR "transitions" IN focus_types:
+        question_categories.append("timing_scale")
+        question_categories.append("easing_philosophy")
 
-      SESSION: {session_id} | MODE: interactive | BASE_PATH: {base_path}
+    IF "all" IN focus_types OR "interactions" IN focus_types OR "hover" IN focus_types:
+        question_categories.append("button_interactions")
+        question_categories.append("card_interactions")
+        question_categories.append("input_interactions")
 
-      ## Context
-      - Design tokens available: {has_design_context}
-      - Focus areas: {focus_types}
-      - Extracted data: {animations_extracted ? "Partial CSS data available" : "No CSS data"}
+    IF "all" IN focus_types OR "page" IN focus_types:
+        question_categories.append("page_transitions")
 
-      ## Interactive Workflow
+    IF "all" IN focus_types OR "loading" IN focus_types:
+        question_categories.append("loading_states")
 
-      For each animation category, ASK user and WAIT for response:
+    IF "all" IN focus_types OR "scroll" IN focus_types:
+        question_categories.append("scroll_animations")
+```
 
-      ### 1. Transition Duration Scale
-      QUESTION: "What timing scale feels right for your design?"
-      OPTIONS:
-        - "Fast & Snappy" (100-200ms transitions)
-        - "Balanced" (200-400ms transitions)
-        - "Smooth & Deliberate" (400-600ms transitions)
-        - "Custom" (specify values)
+### Step 3: Output Questions in Text Format (Main Flow)
 
-      ### 2. Easing Philosophy
-      QUESTION: "What easing style matches your brand?"
-      OPTIONS:
-        - "Linear" (constant speed, technical feel)
-        - "Ease-Out" (fast start, natural feel)
-        - "Ease-In-Out" (balanced, polished feel)
-        - "Spring/Bounce" (playful, modern feel)
-        - "Custom" (specify cubic-bezier)
+```markdown
+# Generate and output structured questions
+REPORT: ""
+REPORT: "===== 动画规格交互式配置 ====="
+REPORT: ""
 
-      ### 3. Common Interactions (Ask for each)
-      FOR interaction IN ["button-hover", "link-hover", "card-hover", "modal-open", "dropdown-toggle"]:
-        QUESTION: "How should {interaction} animate?"
-        OPTIONS:
-          - "Subtle" (color/opacity change only)
-          - "Lift" (scale + shadow increase)
-          - "Slide" (transform translateY)
-          - "Fade" (opacity transition)
-          - "None" (no animation)
-          - "Custom" (describe behavior)
+question_number = 1
+questions_output = []
 
-      ### 4. Page Transitions
-      QUESTION: "Should page/route changes have animations?"
-      IF YES:
-        ASK: "What style?"
-        OPTIONS:
-          - "Fade" (crossfade between views)
-          - "Slide" (swipe left/right)
-          - "Zoom" (scale in/out)
-          - "None"
+# Q1: Timing Scale (if included)
+IF "timing_scale" IN question_categories:
+    REPORT: "【问题{question_number} - 时间尺度】您的设计需要什么样的过渡速度？"
+    REPORT: "a) 快速敏捷"
+    REPORT: "   说明：100-200ms 过渡，适合工具型应用和即时反馈场景"
+    REPORT: "b) 平衡适中"
+    REPORT: "   说明：200-400ms 过渡，通用选择，符合多数用户预期"
+    REPORT: "c) 流畅舒缓"
+    REPORT: "   说明：400-600ms 过渡，适合品牌展示和沉浸式体验"
+    REPORT: "d) 自定义"
+    REPORT: "   说明：需要指定具体数值和使用场景"
+    REPORT: ""
+    questions_output.append({id: question_number, category: "timing_scale", options: ["a", "b", "c", "d"]})
+    question_number += 1
 
-      ### 5. Loading States
-      QUESTION: "What loading animation style?"
-      OPTIONS:
-        - "Spinner" (rotating circle)
-        - "Pulse" (opacity pulse)
-        - "Skeleton" (shimmer effect)
-        - "Progress Bar" (linear fill)
-        - "Custom" (describe)
+# Q2: Easing Philosophy (if included)
+IF "easing_philosophy" IN question_categories:
+    REPORT: "【问题{question_number} - 缓动风格】哪种缓动曲线符合您的品牌调性？"
+    REPORT: "a) 线性匀速"
+    REPORT: "   说明：恒定速度，技术感和精确性，适合数据可视化"
+    REPORT: "b) 快入慢出"
+    REPORT: "   说明：快速启动自然减速，最接近物理世界，通用推荐"
+    REPORT: "c) 慢入慢出"
+    REPORT: "   说明：平滑对称，精致优雅，适合高端品牌"
+    REPORT: "d) 弹性效果"
+    REPORT: "   说明：Spring/Bounce 回弹，活泼现代，适合互动性强的应用"
+    REPORT: ""
+    questions_output.append({id: question_number, category: "easing_philosophy", options: ["a", "b", "c", "d"]})
+    question_number += 1
 
-      ### 6. Micro-interactions
-      QUESTION: "Should form inputs have micro-interactions?"
-      IF YES:
-        ASK: "What interactions?"
-        OPTIONS:
-          - "Focus state animation" (border/shadow transition)
-          - "Error shake" (horizontal shake on error)
-          - "Success check" (checkmark animation)
-          - "All of the above"
+# Q3-5: Interaction Animations (button, card, input - if included)
+IF "button_interactions" IN question_categories:
+    REPORT: "【问题{question_number} - 按钮交互】按钮悬停/点击时如何反馈？"
+    REPORT: "a) 微妙变化"
+    REPORT: "   说明：仅颜色/透明度变化，适合简约设计"
+    REPORT: "b) 抬升效果"
+    REPORT: "   说明：轻微缩放+阴影加深，增强物理感知"
+    REPORT: "c) 滑动移位"
+    REPORT: "   说明：Transform translateY，视觉引导明显"
+    REPORT: "d) 无动画"
+    REPORT: "   说明：静态交互，性能优先或特定品牌要求"
+    REPORT: ""
+    questions_output.append({id: question_number, category: "button_interactions", options: ["a", "b", "c", "d"]})
+    question_number += 1
 
-      ### 7. Scroll Animations
-      QUESTION: "Should elements animate on scroll?"
-      IF YES:
-        ASK: "What scroll animation style?"
-        OPTIONS:
-          - "Fade In" (opacity 0→1)
-          - "Slide Up" (translateY + fade)
-          - "Scale In" (scale 0.9→1 + fade)
-          - "Stagger" (sequential delays)
-          - "None"
+IF "card_interactions" IN question_categories:
+    REPORT: "【问题{question_number} - 卡片交互】卡片悬停时的动画效果？"
+    REPORT: "a) 阴影加深"
+    REPORT: "   说明：Box-shadow 变化，层次感增强"
+    REPORT: "b) 上浮效果"
+    REPORT: "   说明：Transform translateY(-4px)，明显的空间层次"
+    REPORT: "c) 缩放放大"
+    REPORT: "   说明：Scale(1.02)，突出焦点内容"
+    REPORT: "d) 无动画"
+    REPORT: "   说明：静态卡片，性能或设计考量"
+    REPORT: ""
+    questions_output.append({id: question_number, category: "card_interactions", options: ["a", "b", "c", "d"]})
+    question_number += 1
 
-      ## Output Generation
+IF "input_interactions" IN question_categories:
+    REPORT: "【问题{question_number} - 表单交互】输入框是否需要微交互反馈？"
+    REPORT: "a) 聚焦动画"
+    REPORT: "   说明：边框/阴影过渡，清晰的状态指示"
+    REPORT: "b) 错误抖动"
+    REPORT: "   说明：水平shake动画，错误提示更明显"
+    REPORT: "c) 成功勾选"
+    REPORT: "   说明：Checkmark 动画，完成反馈"
+    REPORT: "d) 全部包含"
+    REPORT: "   说明：聚焦+错误+成功的完整反馈体系"
+    REPORT: "e) 无微交互"
+    REPORT: "   说明：标准表单，无额外动画"
+    REPORT: ""
+    questions_output.append({id: question_number, category: "input_interactions", options: ["a", "b", "c", "d", "e"]})
+    question_number += 1
 
-      Based on user responses, generate structured data:
+# Q6: Page Transitions (if included)
+IF "page_transitions" IN question_categories:
+    REPORT: "【问题{question_number} - 页面过渡】页面/路由切换是否需要过渡动画？"
+    REPORT: "a) 淡入淡出"
+    REPORT: "   说明：Crossfade 效果，平滑过渡不突兀"
+    REPORT: "b) 滑动切换"
+    REPORT: "   说明：Swipe left/right，方向性导航"
+    REPORT: "c) 缩放过渡"
+    REPORT: "   说明：Scale in/out，空间层次感"
+    REPORT: "d) 无过渡"
+    REPORT: "   说明：即时切换，性能优先"
+    REPORT: ""
+    questions_output.append({id: question_number, category: "page_transitions", options: ["a", "b", "c", "d"]})
+    question_number += 1
 
-      1. Create animation-specification.json with user choices:
-         - timing_scale (fast/balanced/slow/custom)
-         - easing_philosophy (linear/ease-out/ease-in-out/spring)
-         - interactions: {interaction_name: {type, properties, timing}}
-         - page_transitions: {enabled, style, duration}
-         - loading_animations: {style, duration}
-         - scroll_animations: {enabled, style, stagger_delay}
+# Q7: Loading States (if included)
+IF "loading_states" IN question_categories:
+    REPORT: "【问题{question_number} - 加载状态】加载时使用何种动画风格？"
+    REPORT: "a) 旋转加载器"
+    REPORT: "   说明：Spinner 圆形旋转，通用加载指示"
+    REPORT: "b) 脉冲闪烁"
+    REPORT: "   说明：Opacity pulse，轻量级反馈"
+    REPORT: "c) 骨架屏"
+    REPORT: "   说明：Shimmer effect，内容占位预览"
+    REPORT: "d) 进度条"
+    REPORT: "   说明：Linear fill，进度量化展示"
+    REPORT: ""
+    questions_output.append({id: question_number, category: "loading_states", options: ["a", "b", "c", "d"]})
+    question_number += 1
 
-      2. Write to {base_path}/.intermediates/animation-analysis/animation-specification.json
+# Q8: Scroll Animations (if included)
+IF "scroll_animations" IN question_categories:
+    REPORT: "【问题{question_number} - 滚动动画】元素是否在滚动时触发动画？"
+    REPORT: "a) 淡入出现"
+    REPORT: "   说明：Opacity 0→1，渐进式内容呈现"
+    REPORT: "b) 上滑出现"
+    REPORT: "   说明：TranslateY + fade，方向性引导"
+    REPORT: "c) 缩放淡入"
+    REPORT: "   说明：Scale 0.9→1 + fade，聚焦效果"
+    REPORT: "d) 交错延迟"
+    REPORT: "   说明：Stagger 序列动画，列表渐次呈现"
+    REPORT: "e) 无滚动动画"
+    REPORT: "   说明：静态内容，性能或可访问性考量"
+    REPORT: ""
+    questions_output.append({id: question_number, category: "scroll_animations", options: ["a", "b", "c", "d", "e"]})
+    question_number += 1
 
-      ## Critical Requirements
-      - ✅ Use Write() tool immediately for specification file
-      - ✅ Wait for user response after EACH question before proceeding
-      - ✅ Validate responses and ask for clarification if needed
-      - ✅ Provide sensible defaults if user skips questions
-      - ❌ NO external research or MCP calls
-    `
+REPORT: "支持格式："
+REPORT: "- 空格分隔：1a 2b 3c"
+REPORT: "- 逗号分隔：1a,2b,3c"
+REPORT: "- 自由组合：1a 2b,3c"
+REPORT: ""
+REPORT: "请输入您的选择："
+```
+
+### Step 4: Wait for User Input (Main Flow)
+
+```javascript
+# Wait for user input
+user_raw_input = WAIT_FOR_USER_INPUT()
+
+# Store raw input for debugging
+REPORT: "收到输入: {user_raw_input}"
+```
+
+### Step 5: Parse User Answers (Main Flow)
+
+```javascript
+# Intelligent input parsing (support multiple formats)
+answers = {}
+
+# Parse input using intelligent matching
+# Support formats: "1a 2b 3c", "1a,2b,3c", "1a 2b,3c"
+parsed_responses = PARSE_USER_INPUT(user_raw_input, questions_output)
+
+# Validate parsing
+IF parsed_responses.is_valid:
+    # Map question numbers to categories
+    FOR response IN parsed_responses.answers:
+        question_id = response.question_id
+        selected_option = response.option
+
+        # Find category for this question
+        FOR question IN questions_output:
+            IF question.id == question_id:
+                category = question.category
+                answers[category] = selected_option
+                REPORT: "✅ 问题{question_id} ({category}): 选择 {selected_option}"
+                break
+ELSE:
+    REPORT: "❌ 输入格式无法识别，请参考格式示例重新输入："
+    REPORT: "   示例：1a 2b 3c 4d"
+    # Return to Step 3 for re-input
+    GOTO Step 3
+```
+
+### Step 6: Write Animation Specification (Main Flow)
+
+```javascript
+# Map user choices to specification structure
+specification = {
+    "metadata": {
+        "source": "interactive",
+        "timestamp": NOW(),
+        "focus_types": focus_types,
+        "has_design_context": has_design_context
+    },
+    "timing_scale": MAP_TIMING_SCALE(answers.timing_scale),
+    "easing_philosophy": MAP_EASING_PHILOSOPHY(answers.easing_philosophy),
+    "interactions": {
+        "button": MAP_BUTTON_INTERACTION(answers.button_interactions),
+        "card": MAP_CARD_INTERACTION(answers.card_interactions),
+        "input": MAP_INPUT_INTERACTION(answers.input_interactions)
+    },
+    "page_transitions": MAP_PAGE_TRANSITIONS(answers.page_transitions),
+    "loading_animations": MAP_LOADING_STATES(answers.loading_states),
+    "scroll_animations": MAP_SCROLL_ANIMATIONS(answers.scroll_animations)
+}
+
+# Mapping functions (inline logic)
+FUNCTION MAP_TIMING_SCALE(option):
+    SWITCH option:
+        CASE "a": RETURN {scale: "fast", base_duration: "150ms", range: "100-200ms"}
+        CASE "b": RETURN {scale: "balanced", base_duration: "300ms", range: "200-400ms"}
+        CASE "c": RETURN {scale: "smooth", base_duration: "500ms", range: "400-600ms"}
+        CASE "d": RETURN {scale: "custom", base_duration: "300ms", note: "User to provide values"}
+
+FUNCTION MAP_EASING_PHILOSOPHY(option):
+    SWITCH option:
+        CASE "a": RETURN {style: "linear", curve: "linear"}
+        CASE "b": RETURN {style: "ease-out", curve: "cubic-bezier(0, 0, 0.2, 1)"}
+        CASE "c": RETURN {style: "ease-in-out", curve: "cubic-bezier(0.4, 0, 0.2, 1)"}
+        CASE "d": RETURN {style: "spring", curve: "cubic-bezier(0.34, 1.56, 0.64, 1)"}
+
+FUNCTION MAP_BUTTON_INTERACTION(option):
+    SWITCH option:
+        CASE "a": RETURN {type: "subtle", properties: ["color", "background-color", "opacity"]}
+        CASE "b": RETURN {type: "lift", properties: ["transform", "box-shadow"], transform: "scale(1.02)"}
+        CASE "c": RETURN {type: "slide", properties: ["transform"], transform: "translateY(-2px)"}
+        CASE "d": RETURN {type: "none", properties: []}
+
+FUNCTION MAP_CARD_INTERACTION(option):
+    SWITCH option:
+        CASE "a": RETURN {type: "shadow", properties: ["box-shadow"]}
+        CASE "b": RETURN {type: "float", properties: ["transform", "box-shadow"], transform: "translateY(-4px)"}
+        CASE "c": RETURN {type: "scale", properties: ["transform"], transform: "scale(1.02)"}
+        CASE "d": RETURN {type: "none", properties: []}
+
+FUNCTION MAP_INPUT_INTERACTION(option):
+    SWITCH option:
+        CASE "a": RETURN {enabled: ["focus"], focus: {properties: ["border-color", "box-shadow"]}}
+        CASE "b": RETURN {enabled: ["error"], error: {animation: "shake", keyframes: "translateX"}}
+        CASE "c": RETURN {enabled: ["success"], success: {animation: "checkmark", keyframes: "draw"}}
+        CASE "d": RETURN {enabled: ["focus", "error", "success"]}
+        CASE "e": RETURN {enabled: []}
+
+FUNCTION MAP_PAGE_TRANSITIONS(option):
+    SWITCH option:
+        CASE "a": RETURN {enabled: true, style: "fade", animation: "fadeIn/fadeOut"}
+        CASE "b": RETURN {enabled: true, style: "slide", animation: "slideLeft/slideRight"}
+        CASE "c": RETURN {enabled: true, style: "zoom", animation: "zoomIn/zoomOut"}
+        CASE "d": RETURN {enabled: false}
+
+FUNCTION MAP_LOADING_STATES(option):
+    SWITCH option:
+        CASE "a": RETURN {style: "spinner", animation: "rotate", keyframes: "360deg"}
+        CASE "b": RETURN {style: "pulse", animation: "pulse", keyframes: "opacity"}
+        CASE "c": RETURN {style: "skeleton", animation: "shimmer", keyframes: "gradient-shift"}
+        CASE "d": RETURN {style: "progress", animation: "fill", keyframes: "width"}
+
+FUNCTION MAP_SCROLL_ANIMATIONS(option):
+    SWITCH option:
+        CASE "a": RETURN {enabled: true, style: "fade", animation: "fadeIn"}
+        CASE "b": RETURN {enabled: true, style: "slideUp", animation: "slideUp", transform: "translateY(20px)"}
+        CASE "c": RETURN {enabled: true, style: "scaleIn", animation: "scaleIn", transform: "scale(0.9)"}
+        CASE "d": RETURN {enabled: true, style: "stagger", animation: "fadeIn", stagger_delay: "100ms"}
+        CASE "e": RETURN {enabled: false}
+
+# Write specification file
+output_path = "{base_path}/.intermediates/animation-analysis/animation-specification.json"
+Write(output_path, JSON.stringify(specification, indent=2))
+
+REPORT: "✅ Animation specification saved to {output_path}"
+REPORT: "   Proceeding to token synthesis..."
 ```
 
 ---
 
 **Phase 2 Output**: `animation-specification.json` (user preferences)
 
-## Phase 3: Animation Token Synthesis (Agent)
+## Phase 3: Animation Token Synthesis (Agent - No User Interaction)
 
 **Executor**: `Task(ui-design-agent)` for token generation
 
+**⚠️ CRITICAL**: This phase has NO user interaction. Agent only reads existing data and generates tokens.
+
 ### Step 1: Load All Input Sources
 
 ```bash
@@ -305,61 +495,96 @@ IF animations_extracted:
 user_specification = null
 IF exists({base_path}/.intermediates/animation-analysis/animation-specification.json):
     user_specification = Read(file)
+    REPORT: "✅ Loaded user specification from Phase 2"
+ELSE:
+    REPORT: "⚠️ No user specification found - using extracted CSS only"
 
 design_tokens = null
 IF has_design_context:
     design_tokens = Read({base_path}/style-extraction/style-1/design-tokens.json)
 ```
 
-### Step 2: Launch Token Generation Task
+### Step 2: Launch Token Generation Task (Pure Synthesis)
 
 ```javascript
 Task(ui-design-agent): `
   [ANIMATION_TOKEN_GENERATION_TASK]
-  Synthesize all animation data into production-ready animation tokens
+  Synthesize animation data into production-ready tokens - NO user interaction
 
   SESSION: {session_id} | BASE_PATH: {base_path}
 
-  ## Input Sources
-  1. Extracted CSS Animations: {JSON.stringify(extracted_animations) OR "None"}
-  2. User Specification: {JSON.stringify(user_specification) OR "None"}
-  3. Design Tokens Context: {JSON.stringify(design_tokens) OR "None"}
+  ## ⚠️ CRITICAL: Pure Synthesis Task
+  - NO user questions or interaction
+  - READ existing specification files ONLY
+  - Generate tokens based on available data
+
+  ## Input Sources (Read-Only)
+  1. **Extracted CSS Animations** (if available):
+     ${extracted_animations.length > 0 ? JSON.stringify(extracted_animations) : "None - skip CSS data"}
+
+  2. **User Specification** (REQUIRED if Phase 2 ran):
+     File: {base_path}/.intermediates/animation-analysis/animation-specification.json
+     ${user_specification ? "Status: ✅ Found - READ this file for user choices" : "Status: ⚠️ Not found - use CSS extraction only"}
+
+  3. **Design Tokens Context** (for alignment):
+     ${design_tokens ? JSON.stringify(design_tokens) : "None - standalone animation system"}
 
   ## Synthesis Rules
 
   ### Priority System
-  1. User specification (highest priority)
-  2. Extracted CSS values (medium priority)
+  1. User specification from animation-specification.json (highest priority)
+  2. Extracted CSS values from animations-*.json (medium priority)
   3. Industry best practices (fallback)
 
   ### Duration Normalization
-  - Analyze all extracted durations
-  - Cluster into 3-5 semantic scales: instant, fast, normal, slow, very-slow
+  - IF user_specification.timing_scale EXISTS:
+      Use user's chosen scale (fast/balanced/smooth/custom)
+  - ELSE IF extracted CSS durations available:
+      Cluster extracted durations into 3-5 semantic scales
+  - ELSE:
+      Use standard scale (instant:0ms, fast:150ms, normal:300ms, slow:500ms, very-slow:800ms)
   - Align with design token spacing scale if available
 
   ### Easing Standardization
-  - Identify common easing functions from extracted data
-  - Map to semantic names: linear, ease-in, ease-out, ease-in-out, spring
-  - Convert all cubic-bezier values to standard format
+  - IF user_specification.easing_philosophy EXISTS:
+      Use user's chosen philosophy (linear/ease-out/ease-in-out/spring)
+  - ELSE IF extracted CSS easings available:
+      Identify common easing functions from CSS
+  - ELSE:
+      Use standard easings
+  - Map to semantic names and convert to cubic-bezier format
 
   ### Animation Categorization
   Organize into:
-  - transitions: Property-specific transitions (color, transform, opacity)
-  - keyframe_animations: Named @keyframe animations
-  - interactions: Interaction-specific presets (hover, focus, active)
-  - micro_interactions: Small feedback animations
-  - page_transitions: Route/view change animations
-  - scroll_animations: Scroll-triggered animations
+  - **duration**: Timing scale (instant, fast, normal, slow, very-slow)
+  - **easing**: Easing functions (linear, ease-in, ease-out, ease-in-out, spring)
+  - **transitions**: Property-specific transitions (color, transform, opacity, etc.)
+  - **keyframes**: Named @keyframe animations (fadeIn, slideInUp, pulse, etc.)
+  - **interactions**: Interaction-specific presets (button-hover, card-hover, input-focus, etc.)
+  - **page_transitions**: Route/view change animations (if user enabled)
+  - **scroll_animations**: Scroll-triggered animations (if user enabled)
+
+  ### User Specification Integration
+  IF user_specification EXISTS:
+    - Map user choices to token values:
+      * timing_scale → duration values
+      * easing_philosophy → easing curves
+      * interactions.button → interactions.button-hover token
+      * interactions.card → interactions.card-hover token
+      * interactions.input → micro-interaction tokens
+      * page_transitions → page_transitions tokens
+      * loading_animations → loading state tokens
+      * scroll_animations → scroll_animations tokens
 
   ## Generate Files
 
   ### 1. animation-tokens.json
-  Complete animation token structure:
+  Complete animation token structure using var() references:
 
   {
     "duration": {
       "instant": "0ms",
-      "fast": "150ms",
+      "fast": "150ms",      # Adjust based on user_specification.timing_scale
       "normal": "300ms",
       "slow": "500ms",
       "very-slow": "800ms"
@@ -367,7 +592,7 @@ Task(ui-design-agent): `
     "easing": {
       "linear": "linear",
       "ease-in": "cubic-bezier(0.4, 0, 1, 1)",
-      "ease-out": "cubic-bezier(0, 0, 0.2, 1)",
+      "ease-out": "cubic-bezier(0, 0, 0.2, 1)",      # Adjust based on user_specification.easing_philosophy
       "ease-in-out": "cubic-bezier(0.4, 0, 0.2, 1)",
       "spring": "cubic-bezier(0.34, 1.56, 0.64, 1)"
     },
@@ -389,66 +614,74 @@ Task(ui-design-agent): `
       }
     },
     "keyframes": {
-      "fadeIn": {
-        "0%": {"opacity": "0"},
-        "100%": {"opacity": "1"}
-      },
-      "slideInUp": {
-        "0%": {"transform": "translateY(20px)", "opacity": "0"},
-        "100%": {"transform": "translateY(0)", "opacity": "1"}
-      },
-      "pulse": {
-        "0%, 100%": {"opacity": "1"},
-        "50%": {"opacity": "0.7"}
-      }
+      "fadeIn": {"0%": {"opacity": "0"}, "100%": {"opacity": "1"}},
+      "slideInUp": {"0%": {"transform": "translateY(20px)", "opacity": "0"}, "100%": {"transform": "translateY(0)", "opacity": "1"}},
+      "pulse": {"0%, 100%": {"opacity": "1"}, "50%": {"opacity": "0.7"}},
+      # Add more keyframes based on user_specification choices
     },
     "interactions": {
       "button-hover": {
+        # Map from user_specification.interactions.button
         "properties": ["background-color", "transform"],
         "duration": "var(--duration-fast)",
         "easing": "var(--easing-ease-out)",
         "transform": "scale(1.02)"
       },
       "card-hover": {
+        # Map from user_specification.interactions.card
         "properties": ["box-shadow", "transform"],
         "duration": "var(--duration-normal)",
         "easing": "var(--easing-ease-out)",
         "transform": "translateY(-4px)"
       }
+      # Add input-focus, modal-open, dropdown-toggle based on user choices
     },
     "page_transitions": {
+      # IF user_specification.page_transitions.enabled == true
       "fade": {
         "duration": "var(--duration-normal)",
         "enter": "fadeIn",
         "exit": "fadeOut"
       }
+      # Add slide, zoom based on user_specification.page_transitions.style
     },
     "scroll_animations": {
+      # IF user_specification.scroll_animations.enabled == true
       "default": {
-        "animation": "fadeInUp",
+        "animation": "fadeIn",  # From user_specification.scroll_animations.style
         "duration": "var(--duration-slow)",
         "easing": "var(--easing-ease-out)",
         "threshold": "0.1",
-        "stagger_delay": "100ms"
+        "stagger_delay": "100ms"  # From user_specification if stagger chosen
       }
     }
   }
 
   ### 2. animation-guide.md
-  Comprehensive usage guide:
-  - Animation philosophy and rationale
-  - Duration scale explanation
-  - Easing function usage guidelines
-  - Interaction animation patterns
-  - Implementation examples (CSS and JS)
-  - Accessibility considerations (prefers-reduced-motion)
-  - Performance best practices
+  Comprehensive usage guide with sections:
+  - **Animation Philosophy**: Rationale from user choices and CSS analysis
+  - **Duration Scale**: Explanation of timing values and usage contexts
+  - **Easing Functions**: When to use each easing curve
+  - **Transition Presets**: Property-specific transition guidelines
+  - **Keyframe Animations**: Available animations and use cases
+  - **Interaction Patterns**: Button, card, input animation examples
+  - **Page Transitions**: Route change animation implementation (if enabled)
+  - **Scroll Animations**: Scroll-trigger setup and configuration (if enabled)
+  - **Implementation Examples**: CSS and JavaScript code samples
+  - **Accessibility**: prefers-reduced-motion media query setup
+  - **Performance Best Practices**: Hardware acceleration, will-change usage
+
+  ## Output File Paths
+  - animation-tokens.json: {base_path}/animation-extraction/animation-tokens.json
+  - animation-guide.md: {base_path}/animation-extraction/animation-guide.md
 
   ## Critical Requirements
+  - ✅ READ animation-specification.json if it exists (from Phase 2)
   - ✅ Use Write() tool immediately for both files
-  - ✅ Ensure all tokens use CSS Custom Property format: var(--duration-fast)
+  - ✅ All tokens use CSS Custom Property format: var(--duration-fast)
   - ✅ Include prefers-reduced-motion media query guidance
-  - ✅ Validate all cubic-bezier values are valid
+  - ✅ Validate all cubic-bezier values are valid (4 numbers between 0-1)
+  - ❌ NO user questions or interaction in this phase
   - ❌ NO external research or MCP calls
 `
 ```
@@ -487,8 +720,8 @@ bash(ls -lh {base_path}/animation-extraction/)
 TodoWrite({todos: [
   {content: "Setup and input validation", status: "completed", activeForm: "Validating inputs"},
   {content: "CSS animation extraction (auto mode)", status: "completed", activeForm: "Extracting from CSS"},
-  {content: "Interactive specification (fallback)", status: "completed", activeForm: "Collecting user input"},
-  {content: "Animation token synthesis (agent)", status: "completed", activeForm: "Generating tokens"},
+  {content: "Interactive specification (main flow)", status: "completed", activeForm: "Collecting user input in main flow"},
+  {content: "Animation token synthesis (agent - no interaction)", status: "completed", activeForm: "Generating tokens via agent"},
   {content: "Verify output files", status: "completed", activeForm: "Verifying files"}
 ]});
 ```
@@ -506,7 +739,7 @@ Configuration:
   - ✅ CSS extracted from {len(url_list)} URL(s)
   }
   {IF user_specification:
-  - ✅ User specification via interactive mode
+  - ✅ User specification via interactive mode (main flow)
   }
   {IF has_design_context:
   - ✅ Aligned with existing design tokens
@@ -652,11 +885,12 @@ ERROR: Invalid cubic-bezier values
 
 - **Auto-Trigger CSS Extraction** - Automatically extracts animations when --urls provided
 - **Hybrid Strategy** - Combines CSS extraction with interactive specification
+- **Main Flow Interaction** - User questions in main flow, agent only for token synthesis
 - **Intelligent Fallback** - Gracefully handles extraction failures
 - **Context-Aware** - Aligns with existing design tokens
 - **Production-Ready** - CSS var() format, accessibility support
 - **Comprehensive Coverage** - Transitions, keyframes, interactions, scroll animations
-- **Agent-Driven** - Autonomous token generation with ui-design-agent
+- **Separated Concerns** - User decisions (Phase 2 main flow) → Token generation (Phase 3 agent)
 
 ## Integration
 

.claude/commands/workflow/ui-design/batch-generate.md

@@ -1,6 +1,6 @@
 ---
 name: batch-generate
-description: Prompt-driven batch UI generation using target-style-centric parallel execution
+description: Prompt-driven batch UI generation using target-style-centric parallel execution with design token application
 argument-hint: [--targets "<list>"] [--target-type "page|component"] [--device-type "desktop|mobile|tablet|responsive"] [--base-path <path>] [--session <id>] [--style-variants <count>] [--layout-variants <count>]
 allowed-tools: TodoWrite(*), Read(*), Write(*), Task(ui-design-agent), Bash(*), mcp__exa__web_search_exa(*)
 ---
@@ -129,7 +129,10 @@ Task(ui-design-agent): `
   ## Reference
   - Layout inspiration: Read("{base_path}/.intermediates/layout-analysis/inspirations/{target}-layout-ideas.txt")
   - Design tokens: Read("{base_path}/style-extraction/style-{style_id}/design-tokens.json")
-    Parse ALL token values (colors, typography, spacing, borders, shadows, breakpoints)
+    Parse ALL token values including:
+    * colors, typography (with combinations), spacing, opacity
+    * border_radius, shadows, breakpoints
+    * component_styles (button, card, input variants)
   ${design_attributes ? "- Adapt DOM to: density, visual_weight, formality, organic_vs_geometric" : ""}
 
   ## Generation
@@ -152,14 +155,16 @@ Task(ui-design-agent): `
 
   2. CSS: {base_path}/prototypes/{target}-style-{style_id}-layout-N.css
      - Self-contained: Direct token VALUES (no var())
-     - Use tokens: colors, fonts, spacing, borders, shadows
+     - Use tokens: colors, fonts, spacing, opacity, borders, shadows
+     - IF tokens.component_styles exists: Use component presets for buttons, cards, inputs
+     - IF tokens.typography.combinations exists: Use typography presets for headings and body text
      - Device-optimized: {device_type} styles
      ${device_type === 'responsive' ? '- Responsive: Mobile-first @media' : '- Fixed: ' + device_type}
      ${design_attributes ? `
      - Token selection: density → spacing, visual_weight → shadows` : ""}
 
   ## Notes
-  - ✅ Token VALUES directly from design-tokens.json
+  - ✅ Token VALUES directly from design-tokens.json (with typography.combinations, opacity, component_styles support)
   - ✅ Follow prompt requirements for {target}
   - ✅ Optimize for {device_type}
   - ❌ NO var() refs, NO external deps

.claude/commands/workflow/ui-design/capture.md

@@ -1,6 +1,6 @@
 ---
 name: capture
-description: Batch screenshot capture for UI design workflows using MCP or local fallback
+description: Batch screenshot capture for UI design workflows using MCP puppeteer or local fallback with URL mapping
 argument-hint: --url-map "target:url,..." [--base-path path] [--session id]
 allowed-tools: TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*), ListMcpResourcesTool(*), mcp__chrome-devtools__*, mcp__playwright__*
 ---

.claude/commands/workflow/ui-design/explore-auto.md

@@ -1,6 +1,6 @@
 ---
 name: explore-auto
-description: Exploratory UI design workflow with style-centric batch generation
+description: Exploratory UI design workflow with style-centric batch generation, creates design variants from prompts/images with parallel execution
 argument-hint: "[--prompt "<desc>"] [--images "<glob>"] [--targets "<list>"] [--target-type "page|component"] [--session <id>] [--style-variants <count>] [--layout-variants <count>] [--batch-plan]""
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Glob(*), Write(*), Task(conceptual-planning-agent)
 ---

.claude/commands/workflow/ui-design/explore-layers.md

@@ -1,6 +1,6 @@
 ---
 name: explore-layers
-description: Interactive deep UI capture with depth-controlled layer exploration
+description: Interactive deep UI capture with depth-controlled layer exploration using MCP puppeteer
 argument-hint: --url <url> --depth <1-5> [--session id] [--base-path path]
 allowed-tools: TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*), mcp__chrome-devtools__*
 ---

.claude/commands/workflow/ui-design/generate.md

@@ -1,6 +1,6 @@
 ---
 name: generate
-description: Assemble UI prototypes by combining layout templates with design tokens (pure assembler)
+description: Assemble UI prototypes by combining layout templates with design tokens, pure assembler without new content generation
 argument-hint: [--base-path <path>] [--session <id>] [--style-variants <count>] [--layout-variants <count>]
 allowed-tools: TodoWrite(*), Read(*), Write(*), Task(ui-design-agent), Bash(*)
 ---
@@ -99,7 +99,11 @@ Task(ui-design-agent): `
 
   2. Design Tokens:
      Read("{base_path}/style-extraction/style-{style_id}/design-tokens.json")
-     Extract: ALL token values (colors, typography, spacing, borders, shadows, breakpoints)
+     Extract: ALL token values including:
+       * colors, typography (with combinations), spacing, opacity
+       * border_radius, shadows, breakpoints
+       * component_styles (button, card, input variants)
+     Note: typography.combinations, opacity, and component_styles fields contain preset configurations using var() references
 
   3. Animation Tokens (OPTIONAL):
      IF exists("{base_path}/animation-extraction/animation-tokens.json"):
@@ -133,11 +137,21 @@ Task(ui-design-agent): `
      - Replace ALL var(--*) with actual token values from design-tokens.json
        Example: var(--spacing-4) → 1rem (from tokens.spacing.4)
        Example: var(--breakpoint-md) → 768px (from tokens.breakpoints.md)
+       Example: var(--opacity-80) → 0.8 (from tokens.opacity.80)
      - Add visual styling using design tokens:
        * Colors: tokens.colors.*
-       * Typography: tokens.typography.*
+       * Typography: tokens.typography.* (including combinations)
+       * Opacity: tokens.opacity.*
        * Shadows: tokens.shadows.*
        * Border radius: tokens.border_radius.*
+     - IF tokens.component_styles exists: Add component style classes
+       * Generate classes for button variants (.btn-primary, .btn-secondary)
+       * Generate classes for card variants (.card-default, .card-interactive)
+       * Generate classes for input variants (.input-default, .input-focus, .input-error)
+       * Use var() references that resolve to actual token values
+     - IF tokens.typography.combinations exists: Add typography preset classes
+       * Generate classes for typography presets (.text-heading-primary, .text-body-regular, .text-caption)
+       * Use var() references for family, size, weight, line-height, letter-spacing
      - IF has_animations == true: Inject animation tokens
        * Add CSS Custom Properties for animations at :root level:
          --duration-instant, --duration-fast, --duration-normal, etc.

.claude/commands/workflow/ui-design/imitate-auto.md

@@ -1,6 +1,6 @@
 ---
 name: imitate-auto
-description: High-speed multi-page UI replication with batch screenshot capture
+description: High-speed multi-page UI replication with batch screenshot capture and design token extraction
 argument-hint: --url-map "<map>" [--capture-mode <batch|deep>] [--depth <1-5>] [--session <id>] [--prompt "<desc>"]
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Write(*), Bash(*)
 ---

.claude/commands/workflow/ui-design/layout-extract.md

@@ -1,6 +1,6 @@
 ---
 name: layout-extract
-description: Extract structural layout information from reference images, URLs, or text prompts
+description: Extract structural layout information from reference images, URLs, or text prompts using Claude analysis
 argument-hint: [--base-path <path>] [--session <id>] [--images "<glob>"] [--urls "<list>"] [--prompt "<desc>"] [--targets "<list>"] [--mode <imitate|explore>] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>]
 allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), Bash(*), Task(ui-design-agent), mcp__exa__web_search_exa(*)
 ---

.claude/commands/workflow/ui-design/style-extract.md

@@ -1,6 +1,6 @@
 ---
 name: style-extract
-description: Extract design style from reference images or text prompts using Claude's analysis
+description: Extract design style from reference images or text prompts using Claude analysis with variant generation
 argument-hint: "[--base-path <path>] [--session <id>] [--images "<glob>"] [--urls "<list>"] [--prompt "<desc>"] [--mode <imitate|explore>] [--variants <count>]"
 allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), mcp__chrome-devtools__navigate_page(*), mcp__chrome-devtools__evaluate_script(*)
 ---
@@ -418,17 +418,33 @@ Task(ui-design-agent): `
   Create complete design system in {base_path}/style-extraction/style-1/
 
   1. **design-tokens.json**:
-     - Complete token structure: colors (brand, surface, semantic, text, border), typography (families, sizes, weights, line heights, letter spacing), spacing (0-24 scale), border_radius (none to full), shadows (sm to xl), breakpoints (sm to 2xl)
+     - Complete token structure with ALL fields:
+       * colors (brand, surface, semantic, text, border) - OKLCH format
+       * typography (families, sizes, weights, line heights, letter spacing, combinations)
+       * typography.combinations: Predefined typography presets (heading-primary, heading-secondary, body-regular, body-emphasis, caption, label) using var() references
+       * spacing (0-24 scale)
+       * opacity (0, 10, 20, 40, 60, 80, 90, 100)
+       * border_radius (none to full)
+       * shadows (sm to xl)
+       * component_styles (button, card, input variants) - component presets using var() references
+       * breakpoints (sm to 2xl)
      - All colors in OKLCH format
      ${extraction_mode == "explore" ? "- Start from preview colors and expand to full palette" : ""}
      ${extraction_mode == "explore" && refinements.enabled ? "- Apply user refinements where specified" : ""}
+     - Common Tailwind CSS usage patterns in project (if extracting from existing project)
 
   2. **style-guide.md**:
      - Design philosophy (${extraction_mode == "explore" ? "expand on: " + selected_direction.philosophy_name : "describe the reference design"})
      - Complete color system documentation with accessibility notes
      - Typography scale and usage guidelines
+     - Typography Combinations section: Document each preset (heading-primary, heading-secondary, body-regular, body-emphasis, caption, label) with usage context and code examples
      - Spacing system explanation
+     - Opacity & Transparency section: Opacity scale usage, common use cases (disabled states, overlays, hover effects), accessibility considerations
+     - Shadows & Elevation section: Shadow hierarchy and semantic usage
+     - Component Styles section: Document button, card, and input variants with code examples and visual descriptions
+     - Border Radius system and semantic usage
      - Component examples and usage patterns
+     - Common Tailwind CSS patterns (if applicable)
 
   ## Critical Requirements
   - ✅ Use Write() tool immediately for each file
@@ -577,15 +593,46 @@ bash(test -f {base_path}/.intermediates/style-analysis/analysis-options.json &&
     "text": {"primary": "oklch(...)", "secondary": "oklch(...)", "tertiary": "oklch(...)", "inverse": "oklch(...)"},
     "border": {"default": "oklch(...)", "strong": "oklch(...)", "subtle": "oklch(...)"}
   },
-  "typography": {"font_family": {...}, "font_size": {...}, "font_weight": {...}, "line_height": {...}, "letter_spacing": {...}},
+  "typography": {
+    "font_family": {...},
+    "font_size": {...},
+    "font_weight": {...},
+    "line_height": {...},
+    "letter_spacing": {...},
+    "combinations": {
+      "heading-primary": {"family": "var(--font-family-heading)", "size": "var(--font-size-3xl)", "weight": "var(--font-weight-bold)", "line_height": "var(--line-height-tight)", "letter_spacing": "var(--letter-spacing-tight)"},
+      "heading-secondary": {...},
+      "body-regular": {...},
+      "body-emphasis": {...},
+      "caption": {...},
+      "label": {...}
+    }
+  },
   "spacing": {"0": "0", "1": "0.25rem", ..., "24": "6rem"},
+  "opacity": {"0": "0", "10": "0.1", "20": "0.2", "40": "0.4", "60": "0.6", "80": "0.8", "90": "0.9", "100": "1"},
   "border_radius": {"none": "0", "sm": "0.25rem", ..., "full": "9999px"},
   "shadows": {"sm": "...", "md": "...", "lg": "...", "xl": "..."},
+  "component_styles": {
+    "button": {
+      "primary": {"background": "var(--color-brand-primary)", "color": "var(--color-text-inverse)", "padding": "var(--spacing-3) var(--spacing-6)", "border_radius": "var(--border-radius-md)", "font_weight": "var(--font-weight-semibold)"},
+      "secondary": {...},
+      "tertiary": {...}
+    },
+    "card": {
+      "default": {"background": "var(--color-surface-elevated)", "padding": "var(--spacing-6)", "border_radius": "var(--border-radius-lg)", "shadow": "var(--shadow-md)"},
+      "interactive": {...}
+    },
+    "input": {
+      "default": {"border": "1px solid var(--color-border-default)", "padding": "var(--spacing-3)", "border_radius": "var(--border-radius-md)", "background": "var(--color-surface-background)"},
+      "focus": {...},
+      "error": {...}
+    }
+  },
   "breakpoints": {"sm": "640px", ..., "2xl": "1536px"}
 }
 ```
 
-**Requirements**: OKLCH colors, complete coverage, semantic naming, WCAG AA compliance
+**Requirements**: OKLCH colors, complete coverage, semantic naming, WCAG AA compliance, typography combinations, component style presets, opacity scale
 
 ## Error Handling
 

.claude/commands/workflow/ui-design/update.md

@@ -1,6 +1,6 @@
 ---
 name: update
-description: Update brainstorming artifacts with finalized design system references
+description: Update brainstorming artifacts with finalized design system references from selected prototypes
 argument-hint: --session <session_id> [--selected-prototypes "<list>"]
 allowed-tools: Read(*), Write(*), Edit(*), TodoWrite(*), Glob(*), Bash(*)
 ---

.claude/scripts/update_module_claude.sh

@@ -192,7 +192,7 @@ update_module_claude() {
     fi
 
     # Use unified template for all modules
-    local template_path="$HOME/.claude/workflows/cli-templates/prompts/memory/claude-module-unified.txt"
+    local template_path="$HOME/.claude/workflows/cli-templates/prompts/memory/02-document-module-structure.txt"
 
     # Read template content directly
     local template_content=""

.claude/skills/command-guide/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: command-guide
+description: Workflow command guide for Claude DMS3 (69 commands). Search/browse commands, get next-step recommendations, view documentation, report issues. Triggers "CCW-help", "CCW-issue", "how to use", "search commands", "what's next", beginner onboarding questions
+allowed-tools: Read, Grep, Glob, AskUserQuestion
+---
+
+# Command Guide Skill
+
+Comprehensive command guide for Claude DMS3 workflow system covering 69 commands across 4 categories (workflow, cli, memory, task).
+
+## 🎯 Operation Modes
+
+### Mode 1: Command Search 🔍
+
+**When**: User searches by keyword, category, or use-case
+
+**Triggers**: "搜索命令", "find command", "planning 相关", "search"
+
+**Process**:
+1. Identify search type (keyword/category/use-case)
+2. Query appropriate index (all-commands/by-category/by-use-case)
+3. Return matching commands with metadata
+4. Suggest related commands
+
+**Example**: "搜索 planning 命令" → Lists planning commands from `index/by-use-case.json`
+
+---
+
+### Mode 2: Smart Recommendations 🤖
+
+**When**: User asks for next steps after a command
+
+**Triggers**: "下一步", "what's next", "after /workflow:plan", "推荐"
+
+**Process**:
+1. Parse current context (last command/workflow state)
+2. Query `index/command-relationships.json`
+3. Return recommended next commands with rationale
+4. Show common workflow patterns
+
+**Example**: "执行完 /workflow:plan 后做什么？" → Recommends /workflow:execute or /workflow:action-plan-verify
+
+---
+
+### Mode 3: Full Documentation 📖
+
+**When**: User requests command details
+
+**Triggers**: "参数说明", "怎么用", "how to use", "详情"
+
+**Process**:
+1. Locate command in `index/all-commands.json`
+2. Read original command file for full details
+3. Present parameters, arguments, examples
+4. Link to related commands
+
+**Example**: "/workflow:plan 的参数是什么？" → Shows full parameter list and usage examples
+
+---
+
+### Mode 4: Beginner Onboarding 🎓
+
+**When**: New user needs guidance
+
+**Triggers**: "新手", "getting started", "如何开始", "常用命令"
+
+**Process**:
+1. Present progressive learning path
+2. Show `index/essential-commands.json` (Top 14 commands)
+3. Link to getting-started guide
+4. Provide first workflow example
+
+**Example**: "我是新手，如何开始？" → Learning path + Top 14 commands + quick start guide
+
+---
+
+### Mode 5: Issue Reporting 📝
+
+**When**: User wants to report issue or request feature
+
+**Triggers**: **"CCW-issue"**, **"CCW-help"**, "报告 bug", "功能建议", "问题咨询"
+
+**Process**:
+1. Use AskUserQuestion to confirm type (bug/feature/question)
+2. Collect required information interactively
+3. Select appropriate template (`templates/issue-{type}.md`)
+4. Generate filled template and save/display
+
+**Example**: "CCW-issue" → Interactive Q&A → Generates GitHub issue template
+
+---
+
+## 📚 Index Files
+
+All command metadata is stored in JSON indexes for fast querying:
+
+- **all-commands.json** - Complete catalog (69 commands) with full metadata
+- **by-category.json** - Hierarchical organization (workflow/cli/memory/task)
+- **by-use-case.json** - Grouped by scenario (planning/implementation/testing/docs/session)
+- **essential-commands.json** - Top 14 most-used commands
+- **command-relationships.json** - Next-step recommendations and dependencies
+
+📖 Detailed structure: [Index Structure Reference](guides/index-structure.md)
+
+---
+
+## 🗂️ Supporting Guides
+
+- **[Getting Started](guides/getting-started.md)** - 5-minute quickstart for beginners
+- **[Workflow Patterns](guides/workflow-patterns.md)** - Common workflow examples (Plan→Execute, TDD, UI design)
+- **[CLI Tools Guide](guides/cli-tools-guide.md)** - Gemini/Qwen/Codex usage
+- **[Troubleshooting](guides/troubleshooting.md)** - Common issues and solutions
+- **[Implementation Details](guides/implementation-details.md)** - Detailed logic for each mode
+- **[Usage Examples](guides/examples.md)** - Example dialogues and edge cases
+
+---
+
+## 🛠️ Issue Templates
+
+Generate standardized GitHub issue templates:
+
+- **[Bug Report](templates/issue-bug.md)** - Report command errors or system bugs
+- **[Feature Request](templates/issue-feature.md)** - Suggest new features or improvements
+- **[Question](templates/issue-question.md)** - Ask usage questions or request help
+
+Templates are auto-populated during Mode 5 (Issue Reporting) interaction.
+
+---
+
+## 📊 System Statistics
+
+- **Total Commands**: 69
+- **Categories**: 4 (workflow: 46, cli: 9, memory: 8, task: 4, general: 2)
+- **Use Cases**: 5 (planning, implementation, testing, documentation, session-management)
+- **Difficulty Levels**: 3 (Beginner, Intermediate, Advanced)
+- **Essential Commands**: 14
+
+---
+
+## 🔧 Maintenance
+
+### Updating Indexes
+
+When commands are added/modified/removed:
+
+```bash
+bash scripts/update-index.sh
+```
+
+This script:
+1. Scans all command files in `../../commands/`
+2. Extracts metadata from YAML frontmatter
+3. Analyzes command relationships
+4. Regenerates all 5 index files
+
+### Committing Updates
+
+```bash
+git add .claude/skills/command-guide/index/
+git commit -m "docs: update command indexes"
+git push
+```
+
+Team members get latest indexes via `git pull`.
+
+---
+
+## 📖 Related Documentation
+
+- [Workflow Architecture](../../workflows/workflow-architecture.md) - System design overview
+- [Intelligent Tools Strategy](../../workflows/intelligent-tools-strategy.md) - CLI tool selection
+- [Context Search Strategy](../../workflows/context-search-strategy.md) - Search patterns
+- [Task Core](../../workflows/task-core.md) - Task system fundamentals
+
+---
+
+**Version**: 1.1.0
+**Last Updated**: 2025-11-06
+**Maintainer**: Claude DMS3 Team

.claude/skills/command-guide/guides/cli-tools-guide.md

@@ -0,0 +1,64 @@
+# CLI 智能工具指南
+
+Gemini CLI 能够集成多种智能工具（如大型语言模型 LLM），以增强您的开发工作流。本指南将帮助您理解这些智能工具如何工作，以及如何有效地利用它们。
+
+## 1. 什么是智能工具？
+
+智能工具是集成到 Gemini CLI 中的高级 AI 模型，它们能够理解自然语言、分析代码、生成文本和代码，并协助完成复杂的开发任务。它们就像您的智能助手，可以自动化重复性工作，提供洞察，并帮助您做出更好的决策。
+
+## 2. 核心工作原理
+
+Gemini CLI 中的智能工具遵循以下核心原则：
+
+-   **上下文感知**: 工具会理解您当前的项目状态、代码内容和开发意图，从而提供更相关的建议和操作。这意味着它们不会“凭空”回答问题，而是基于您的实际工作环境提供帮助。
+-   **模块化**: 智能工具被设计为可互换的后端。您可以根据任务需求选择或组合不同的 LLM。例如，某些模型可能擅长代码生成，而另一些则擅长复杂推理。
+-   **自动化与增强**: 智能工具可以自动化重复或复杂的任务（如生成样板代码、基础重构、测试脚手架），并通过提供智能建议、解释和问题解决协助来增强您的开发能力。
+-   **用户控制与透明**: 您始终对工具的操作拥有最终控制权。工具会清晰地解释其建议的更改，并允许您轻松审查和修改。工具的选择和执行过程也是透明的。
+
+详情可参考 `../../workflows/intelligent-tools-strategy.md`。
+
+## 3. 智能工具的应用场景
+
+智能工具被集成到 CLI 工作流的多个关键点，以提供全面的帮助：
+
+-   **提示增强**: 优化您的输入提示，使智能工具更好地理解您的需求。
+    -   **命令**: `enhance-prompt`
+-   **代码分析与审查**: 快速洞察代码，识别潜在问题，并提出改进建议。
+    -   **命令**: `analyze`, `chat`, `code-analysis`, `bug-diagnosis`
+-   **规划与任务分解**: 协助将复杂问题分解为可管理的小任务，并生成实施计划。
+    -   **命令**: `plan`, `discuss-plan`, `breakdown`
+-   **代码生成与实现**: 根据您的规范生成代码片段、函数、测试甚至整个模块。
+    -   **命令**: `execute`, `create`, `codex-execute`
+-   **测试与调试**: 生成测试用例，诊断错误，并建议修复方案。
+    -   **命令**: `test-gen`, `test-fix-gen`, `tdd-plan`, `tdd-verify`
+-   **文档生成**: 自动化代码、API 和项目模块的文档创建。
+    -   **命令**: `docs`, `skill-memory`, `update-full`, `update-related`
+-   **工作流编排**: 智能选择和协调工具与代理来执行复杂的工作流。
+    -   **命令**: `workflow:status`, `resume`, `plan`, `execute` (工作流级别)
+
+## 4. 如何选择和使用工具
+
+Gemini CLI 允许您使用 `--tool` 标志来指定用于特定操作的智能工具。这为您提供了灵活性，可以根据任务的性质选择最合适的模型。
+
+-   `--tool codex`: 优先使用 Codex（或兼容的专注于代码的 LLM）。非常适合精确的代码生成、重构和类似 linting 的任务。
+    -   **何时使用**: 当您需要生成高质量代码、进行代码审查或修复代码错误时。
+-   `--tool gemini`: 优先使用 Gemini（或兼容的通用 LLM）。擅长复杂的推理、更广泛的分析、规划和自然语言理解任务。
+    -   **何时使用**: 当您需要进行高层次的规划、理解复杂概念或进行广泛的代码库分析时。
+-   `--tool qwen`: 优先使用 Qwen（或兼容的特定领域/语言 LLM）。适用于需要专业知识或特定语言支持的任务。
+    -   **何时使用**: 当您的项目涉及特定技术栈或需要特定语言的专业知识时。
+-   **(默认/自动)**: 如果未指定工具，CLI 会根据任务上下文和可用配置智能地选择最合适的工具。
+
+**示例**:
+
+```bash
+# 使用 Gemini 进行项目规划
+gemini plan --tool gemini "设计一个新的微服务架构"
+
+# 使用 Codex 生成代码
+gemini execute --tool codex "task-id-for-code-generation"
+
+# 使用 Qwen 分析特定领域的代码
+gemini analyze --tool qwen "分析医疗数据处理模块"
+```
+
+通过理解这些智能工具及其用法，您可以更有效地利用 Gemini CLI，加速您的开发过程。

.claude/skills/command-guide/guides/examples.md

@@ -0,0 +1,537 @@
+# Usage Examples
+
+Comprehensive examples of command-guide skill in action across all 5 operation modes.
+
+---
+
+## Mode 1: Command Search 🔍
+
+### Example 1: Keyword Search
+
+**User**: "搜索包含 'execute' 的命令"
+
+**Skill Response**:
+```
+找到 4 个相关命令：
+
+1. **cli:execute** (高级)
+   描述: Auto-execution of implementation tasks with YOLO permissions
+   参数: [--agent] [--tool codex|gemini|qwen] [--enhance] description or task-id
+   场景: implementation
+
+2. **task:execute** (中级)
+   描述: Execute tasks with appropriate agents and context-aware orchestration
+   参数: task-id
+   场景: implementation
+
+3. **workflow:execute** (中级)
+   描述: Coordinate agents for existing workflow tasks with automatic discovery
+   参数: [--resume-session="session-id"]
+   场景: implementation
+
+4. **codex-execute** (高级)
+   描述: Automated task decomposition and execution with Codex
+   参数: task description or task-id
+   场景: implementation
+
+💡 相关命令: workflow:plan, task:create
+📖 详细文档: [Implementation Commands](workflow-patterns.md#implementation)
+```
+
+---
+
+### Example 2: Category Search
+
+**User**: "cli 类别下有哪些命令？"
+
+**Skill Response**:
+```
+CLI 类别包含 9 个命令：
+
+**核心命令** (6个):
+- cli:analyze - Quick codebase analysis
+- cli:chat - Direct codebase interaction
+- cli:execute - Auto-execution with YOLO
+- cli:cli-init - Initialize CLI tool configs
+- cli:codex-execute - Codex-powered execution
+- cli:discuss-plan - Multi-model planning discussion
+
+**模式命令** (3个):
+- cli:mode:plan - Project planning mode
+- cli:mode:code-analysis - Deep code analysis mode
+- cli:mode:bug-diagnosis - Bug diagnosis mode
+
+📚 使用指南: [CLI Tools Guide](cli-tools-guide.md)
+```
+
+---
+
+### Example 3: Use-Case Search
+
+**User**: "planning 相关的命令有哪些？"
+
+**Skill Response**:
+```
+Planning 场景包含 8 个命令：
+
+**核心规划**:
+1. workflow:plan (高级) - 5阶段规划工作流
+2. cli:mode:plan (高级) - 项目规划和架构分析
+3. workflow:tdd-plan (高级) - TDD 规划工作流
+
+**任务分解**:
+4. task:breakdown (中级) - 智能任务分解
+5. workflow:tools:task-generate (中级) - 生成任务 JSON
+
+**架构设计**:
+6. workflow:brainstorm:system-architect (中级) - 系统架构师头脑风暴
+7. workflow:brainstorm:api-designer (中级) - API 设计师头脑风暴
+
+**评估验证**:
+8. workflow:action-plan-verify (中级) - 规划质量验证
+
+💡 常见工作流: Plan → Verify → Execute
+📖 模式参考: [Workflow Patterns](workflow-patterns.md#planning-workflow)
+```
+
+---
+
+## Mode 2: Smart Recommendations 🤖
+
+### Example 1: After Planning
+
+**User**: "执行完 /workflow:plan 后下一步做什么？"
+
+**Skill Response**:
+```
+推荐的后续步骤：
+
+**🎯 主要选择**:
+1. **/workflow:execute** - 开始执行规划的任务
+   ✅ 这是最常见的下一步
+   作用: 实际执行 workflow:plan 生成的任务
+
+**📋 可选步骤**:
+2. **/workflow:action-plan-verify** - 验证规划质量
+   作用: 在执行前检查规划的一致性和完整性
+   建议: 重要项目建议先验证
+
+3. **/workflow:status** - 查看规划状态
+   作用: 查看生成的任务和当前进度
+
+**📚 完整工作流模式**:
+Plan → Verify (可选) → Execute → Review
+
+详见: [Planning Workflow Pattern](workflow-patterns.md#planning-execution)
+```
+
+---
+
+### Example 2: After Execution
+
+**User**: "workflow:execute 执行完成后，推荐做什么？"
+
+**Skill Response**:
+```
+推荐的后续步骤：
+
+**🎯 主要选择**:
+1. **/workflow:review** - 审查实现结果
+   ✅ 检查代码质量、安全性、架构
+   参数: [--type=quality|security|architecture]
+
+**📊 可选步骤**:
+2. **/workflow:status** - 查看执行状态
+   作用: 确认所有任务都已完成
+
+3. **/workflow:test-gen** - 生成测试
+   作用: 为实现的功能创建测试用例
+
+4. **/workflow:session:complete** - 完成会话
+   作用: 标记工作流已完成，归档经验
+
+**🔄 如果需要修改**:
+- /task:replan - 重新规划某个任务
+- /workflow:resume - 恢复工作流
+
+详见: [Execution Review Pattern](workflow-patterns.md#execution-review)
+```
+
+---
+
+## Mode 3: Full Documentation 📖
+
+### Example 1: Command Parameters
+
+**User**: "/workflow:plan 的参数是什么？"
+
+**Skill Response**:
+```
+# workflow:plan
+
+**描述**: Orchestrate 5-phase planning workflow with quality gate, executing commands and passing context between phases
+
+**参数**:
+```bash
+/workflow:plan [--agent] [--cli-execute] "text description"|file.md
+```
+
+**参数说明**:
+- `--agent` (可选): 使用 agent 模式执行规划
+- `--cli-execute` (可选): 允许在规划阶段执行 CLI 命令
+- `"text description"`: 任务描述文本
+- `file.md`: 或者提供任务描述文件路径
+
+**使用场景**: planning
+**难度级别**: 高级
+
+**使用示例**:
+```bash
+# 基本用法
+/workflow:plan "实现用户认证功能"
+
+# 使用 agent 模式
+/workflow:plan --agent "重构支付模块"
+
+# 从文件读取
+/workflow:plan --agent feature-spec.md
+
+# 允许 CLI 执行
+/workflow:plan --cli-execute "添加搜索功能"
+```
+
+**执行流程**:
+1. 上下文收集
+2. 概念规划
+3. 实现规划
+4. 任务生成
+5. 质量验证
+
+**相关命令**:
+- workflow:execute - 执行规划的任务
+- workflow:action-plan-verify - 验证规划质量
+- workflow:status - 查看规划状态
+
+**详细文档**: ../../commands/workflow/plan.md
+```
+
+---
+
+## Mode 4: Beginner Onboarding 🎓
+
+### Example 1: Complete Beginner
+
+**User**: "我是新手，如何开始使用工作流系统？"
+
+**Skill Response**:
+```
+欢迎使用 Claude DMS3 工作流系统！🎉
+
+## 🚀 快速开始（3 步）
+
+### Step 1: 了解核心命令（Top 5）
+
+1. **/workflow:plan** - 规划一个功能或任务
+   用法: /workflow:plan "你想做的事情"
+
+2. **/workflow:execute** - 执行规划的任务
+   用法: /workflow:execute
+
+3. **/cli:execute** - 快速自动执行
+   用法: /cli:execute "实现XXX功能"
+
+4. **/task:create** - 创建单个任务
+   用法: /task:create "任务标题"
+
+5. **/enhance-prompt** - 优化你的提示词
+   用法: /enhance-prompt "你的想法"
+
+### Step 2: 尝试第一个工作流
+
+```bash
+# 1. 规划一个简单功能
+/workflow:plan "添加用户登录功能"
+
+# 2. 执行规划
+/workflow:execute
+
+# 3. 审查结果
+/workflow:review
+```
+
+### Step 3: 学习资源
+
+📖 **必读指南**:
+- [5分钟快速开始](getting-started.md)
+- [常见工作流模式](workflow-patterns.md)
+
+🛠️ **工具指南**:
+- [CLI 工具使用](cli-tools-guide.md)
+- [问题排查](troubleshooting.md)
+
+💡 **下一步建议**:
+1. 阅读 getting-started.md（5分钟）
+2. 尝试上面的第一个工作流
+3. 探索更多命令: 询问 "常用命令有哪些"
+
+有问题随时问 "CCW-help"！
+```
+
+---
+
+### Example 2: Intermediate User
+
+**User**: "常用命令有哪些？"
+
+**Skill Response**:
+```
+## 核心命令列表（Top 14）
+
+### 🎯 工作流管理 (5个)
+1. workflow:plan - 5阶段规划
+2. workflow:execute - 执行任务
+3. workflow:review - 审查实现
+4. workflow:tdd-plan - TDD 规划
+5. workflow:test-gen - 生成测试
+
+### 🛠️ CLI 工具 (3个)
+6. cli:execute - 自动执行
+7. cli:mode:plan - 规划模式
+8. cli:analyze - 代码分析
+
+### 📋 任务管理 (3个)
+9. task:create - 创建任务
+10. task:execute - 执行任务
+11. task:breakdown - 分解任务
+
+### 🔧 实用工具 (2个)
+12. enhance-prompt - 提示词增强
+13. version - 版本信息
+
+### 💡 使用频率
+- **每天**: workflow:plan, workflow:execute, cli:execute
+- **经常**: task:create, enhance-prompt
+- **按需**: workflow:review, test-gen, tdd-plan
+
+📚 详细文档: [Index Structure](index-structure.md#essential-commands)
+```
+
+---
+
+## Mode 5: Issue Reporting 📝
+
+### Example 1: Bug Report
+
+**User**: "CCW-issue"
+
+**Skill (Interactive)**:
+```
+请选择问题类型：
+1. 🐛 Bug 报告
+2. ✨ 功能请求
+3. ❓ 问题咨询
+```
+
+**User**: "1"
+
+**Skill**:
+```
+好的，我将帮您创建 Bug 报告。请回答以下问题：
+
+1. 简要描述问题：
+```
+
+**User**: "/workflow:plan 执行后没有生成任务文件"
+
+**Skill**:
+```
+2. 您执行的完整命令是什么？
+```
+
+**User**: "/workflow:plan '添加登录功能'"
+
+**Skill**:
+```
+3. 期望的结果是什么？
+```
+
+**User**: "应该在 .workflow/ 目录生成 task.json"
+
+**Skill**:
+```
+4. 实际发生了什么？
+```
+
+**User**: "命令执行了但没有生成文件"
+
+**Skill**:
+```
+✅ Bug 报告已生成！
+
+文件路径: templates/.generated/bug-2025-01-06-123456.md
+
+--- 报告内容 ---
+# Bug 报告
+
+## 问题描述
+/workflow:plan 执行后没有生成任务文件
+
+## 执行的命令
+```bash
+/workflow:plan '添加登录功能'
+```
+
+## 期望行为
+应该在 .workflow/ 目录生成 task.json
+
+## 实际行为
+命令执行了但没有生成文件
+
+## 环境信息
+- 操作系统: Windows
+- 报告日期: 2025-01-06
+- 相关命令: /workflow:plan
+
+---
+
+**下一步操作**:
+1. 复制以上内容到 GitHub Issues
+2. 或使用: gh issue create -F templates/.generated/bug-2025-01-06-123456.md
+
+需要更多帮助？使用 "CCW-help"
+```
+
+---
+
+### Example 2: Feature Request
+
+**User**: "我想提个功能建议"
+
+**Skill (Interactive)**:
+```
+请选择问题类型：
+1. 🐛 Bug 报告
+2. ✨ 功能请求
+3. ❓ 问题咨询
+```
+
+**User**: "2"
+
+**Skill**:
+```
+好的，功能请求。请描述：
+
+1. 您希望添加什么功能？
+```
+
+**User**: "希望 /workflow:plan 能自动估算任务时间"
+
+**Skill**:
+```
+2. 这个功能解决什么问题？
+```
+
+**User**: "帮助更好地规划项目进度和资源分配"
+
+**Skill**:
+```
+3. 具体的使用场景是什么？（可选）
+```
+
+**User**: "规划大型项目时，能看到预计完成时间"
+
+**Skill**:
+```
+✅ 功能请求已生成！
+
+文件路径: templates/.generated/feature-2025-01-06-123457.md
+
+--- 内容预览 ---
+# 功能请求
+
+## 功能概述
+希望 /workflow:plan 能自动估算任务时间
+
+## 问题背景
+帮助更好地规划项目进度和资源分配
+
+## 使用场景
+规划大型项目时，能看到预计完成时间
+
+## 优先级
+- [ ] 高 - 严重影响工作效率
+- [x] 中 - 有明显改善但有变通方案
+- [ ] 低 - 锦上添花
+
+---
+
+可以复制到 GitHub 提交，或使用:
+gh issue create -F templates/.generated/feature-2025-01-06-123457.md
+```
+
+---
+
+## Edge Cases & Error Handling
+
+### Case 1: No Results Found
+
+**User**: "搜索 xyz 命令"
+
+**Skill**:
+```
+❌ 未找到包含 "xyz" 的命令
+
+💡 建议：
+1. 尝试更广泛的关键词（如 "plan", "execute", "test"）
+2. 按类别浏览：workflow, cli, memory, task
+3. 查看所有常用命令：询问 "常用命令"
+4. 需要帮助：使用 "CCW-help"
+
+📚 快速参考：[All Commands Index](index-structure.md#all-commands)
+```
+
+---
+
+### Case 2: Ambiguous Query
+
+**User**: "命令"
+
+**Skill**:
+```
+您想了解什么？请选择：
+
+1. 🔍 搜索特定命令
+2. 🤖 获取命令推荐
+3. 📖 查看命令文档
+4. 🎓 新手入门指导
+5. 📝 报告问题或建议
+
+或者直接说出具体需求，例如：
+- "搜索 planning 命令"
+- "执行完 /workflow:plan 下一步做什么"
+- "/task:create 怎么用"
+```
+
+---
+
+### Case 3: Multiple Matches
+
+**User**: "execute 命令"
+
+**Skill**:
+```
+找到多个相关命令，请选择您需要的：
+
+1. **cli:execute** - CLI 自动执行（推荐新手）
+2. **task:execute** - 执行单个任务
+3. **workflow:execute** - 执行整个工作流
+
+或者询问：
+- "cli:execute 的详细文档"
+- "三者有什么区别"
+- "我该用哪个"
+```
+
+---
+
+**Last Updated**: 2025-01-06

.claude/skills/command-guide/guides/getting-started.md

@@ -0,0 +1,95 @@
+# 5分钟快速上手指南
+
+欢迎来到 Gemini CLI！本指南将帮助您快速了解核心命令，并通过一个简单的工作流示例，让您在5分钟内开始使用。
+
+## 1. Gemini CLI 简介
+
+Gemini CLI 是一个强大的命令行工具，旨在通过智能代理和自动化工作流，提升您的开发效率。它能够帮助您进行代码分析、任务规划、代码生成、测试以及文档编写等。
+
+## 2. 核心命令速览
+
+以下是一些您将频繁使用的核心命令：
+
+### `version` - 查看版本信息
+- **用途**: 检查当前 CLI 版本并获取更新信息。
+- **示例**:
+  ```bash
+  gemini version
+  ```
+
+### `enhance-prompt` - 智能提示增强
+- **用途**: 根据当前会话记忆和代码库分析，智能地优化您的输入提示，让代理更好地理解您的意图。
+- **示例**:
+  ```bash
+  gemini enhance-prompt "如何修复这个bug？"
+  ```
+
+### `analyze` - 快速代码分析
+- **用途**: 使用 CLI 工具（如 Codex, Gemini, Qwen）对代码库进行快速分析，获取洞察。
+- **示例**:
+  ```bash
+  gemini analyze "分析 src/main.py 中的性能瓶颈"
+  ```
+
+### `chat` - 交互式对话
+- **用途**: 与 CLI 进行简单的交互式对话，直接进行代码分析或提问。
+- **示例**:
+  ```bash
+  gemini chat "解释一下 UserService.java 的主要功能"
+  ```
+
+### `plan` - 项目规划与架构分析
+- **用途**: 启动项目规划和架构分析工作流，帮助您将复杂问题分解为可执行的任务。
+- **示例**:
+  ```bash
+  gemini plan "实现用户认证模块"
+  ```
+
+### `create` - 创建实现任务
+- **用途**: 根据上下文创建具体的实现任务。
+- **示例**:
+  ```bash
+  gemini create "编写用户注册接口"
+  ```
+
+### `execute` - 自动执行任务
+- **用途**: 自动执行实现任务，智能地推断上下文并协调代理完成工作。
+- **示例**:
+  ```bash
+  gemini execute "task-id-123"
+  ```
+
+## 3. 第一个工作流示例：规划与执行一个简单任务
+
+让我们通过一个简单的例子来体验 Gemini CLI 的工作流：**规划并实现一个“Hello World”函数**。
+
+1.  **规划任务**:
+    首先，我们使用 `plan` 命令来规划我们的“Hello World”功能。
+    ```bash
+    gemini plan "实现一个打印 'Hello World!' 的 Python 函数"
+    ```
+    CLI 将会启动一个规划工作流，可能会询问您一些问题，并最终生成一个或多个任务。
+
+2.  **创建具体任务**:
+    假设 `plan` 命令为您生成了一个任务 ID，或者您想手动创建一个任务。
+    ```bash
+    gemini create "编写 Python 函数 `say_hello` 打印 'Hello World!'"
+    ```
+    这个命令会创建一个新的任务，并返回一个任务 ID。
+
+3.  **执行任务**:
+    现在，我们使用 `execute` 命令来让 CLI 自动完成这个任务。请将 `your-task-id` 替换为上一步中获得的实际任务 ID。
+    ```bash
+    gemini execute "your-task-id"
+    ```
+    CLI 将会调用智能代理，根据任务描述生成代码，并尝试将其写入文件。
+
+通过这三个简单的步骤，您就完成了一个从规划到执行的完整工作流。
+
+## 4. 接下来做什么？
+
+- 探索更多命令：使用 `gemini help` 查看所有可用命令。
+- 查阅其他指南：深入了解工作流模式、CLI 工具使用和故障排除。
+- 尝试更复杂的任务：挑战自己，使用 Gemini CLI 解决实际项目中的问题。
+
+祝您使用愉快！

.claude/skills/command-guide/guides/implementation-details.md

@@ -0,0 +1,526 @@
+# Implementation Details
+
+Detailed implementation logic for command-guide skill operation modes.
+
+## Architecture Overview
+
+```
+User Query
+    ↓
+Intent Recognition
+    ↓
+Mode Selection (1 of 5)
+    ↓
+Index/File Query
+    ↓
+Response Formation
+    ↓
+User Output + Recommendations
+```
+
+---
+
+## Intent Recognition
+
+### Step 1: Parse User Input
+
+Analyze query for trigger keywords and patterns:
+
+```javascript
+function recognizeIntent(userQuery) {
+  const query = userQuery.toLowerCase();
+
+  // Mode 5: Issue Reporting (highest priority)
+  if (query.includes('ccw-issue') || query.includes('ccw-help') ||
+      query.match(/报告.*bug/) || query.includes('功能建议')) {
+    return 'ISSUE_REPORTING';
+  }
+
+  // Mode 1: Command Search
+  if (query.includes('搜索') || query.includes('find') ||
+      query.includes('search') || query.match(/.*相关.*命令/)) {
+    return 'COMMAND_SEARCH';
+  }
+
+  // Mode 2: Recommendations
+  if (query.includes('下一步') || query.includes("what's next") ||
+      query.includes('推荐') || query.match(/after.*\/\w+:\w+/)) {
+    return 'RECOMMENDATIONS';
+  }
+
+  // Mode 3: Documentation
+  if (query.includes('参数') || query.includes('怎么用') ||
+      query.includes('如何使用') || query.match(/\/\w+:\w+.*详情/)) {
+    return 'DOCUMENTATION';
+  }
+
+  // Mode 4: Onboarding
+  if (query.includes('新手') || query.includes('入门') ||
+      query.includes('getting started') || query.includes('常用命令')) {
+    return 'ONBOARDING';
+  }
+
+  // Default: Ask for clarification
+  return 'CLARIFY';
+}
+```
+
+---
+
+## Mode 1: Command Search 🔍
+
+### Trigger Analysis
+
+**Keywords**: 搜索, find, search, [topic] 相关命令
+
+**Examples**:
+- "搜索 planning 命令"
+- "find commands for testing"
+- "实现相关的命令有哪些"
+
+### Processing Flow
+
+```
+1. Extract Search Parameters
+   ↓
+2. Determine Search Type
+   ├─ Keyword Search (in name/description)
+   ├─ Category Search (workflow/cli/memory/task)
+   └─ Use-Case Search (planning/implementation/testing)
+   ↓
+3. Query Appropriate Index
+   ├─ Keyword → all-commands.json
+   ├─ Category → by-category.json
+   └─ Use-Case → by-use-case.json
+   ↓
+4. Filter and Rank Results
+   ↓
+5. Format Response
+   ├─ List matching commands
+   ├─ Show key metadata (name, description, args)
+   └─ Suggest related commands
+```
+
+### Implementation
+
+```javascript
+async function searchCommands(query, searchType) {
+  let results = [];
+
+  switch (searchType) {
+    case 'keyword':
+      // Load all-commands.json
+      const allCommands = await readIndex('all-commands.json');
+      results = allCommands.filter(cmd =>
+        cmd.name.toLowerCase().includes(query.toLowerCase()) ||
+        cmd.description.toLowerCase().includes(query.toLowerCase())
+      );
+      break;
+
+    case 'category':
+      // Load by-category.json
+      const byCategory = await readIndex('by-category.json');
+      const category = extractCategory(query); // e.g., "workflow"
+      results = flattenCategory(byCategory[category]);
+      break;
+
+    case 'use-case':
+      // Load by-use-case.json
+      const byUseCase = await readIndex('by-use-case.json');
+      const useCase = extractUseCase(query); // e.g., "planning"
+      results = byUseCase[useCase] || [];
+      break;
+  }
+
+  // Rank by relevance
+  results = rankResults(results, query);
+
+  // Add related commands
+  results = await enrichWithRelated(results);
+
+  return results;
+}
+```
+
+---
+
+## Mode 2: Smart Recommendations 🤖
+
+### Trigger Analysis
+
+**Keywords**: 下一步, what's next, 推荐, after [command]
+
+**Examples**:
+- "执行完 /workflow:plan 后做什么？"
+- "What's next after planning?"
+- "推荐下一个命令"
+
+### Processing Flow
+
+```
+1. Extract Context
+   ├─ Current/Last Command
+   ├─ Workflow State
+   └─ User's Current Task
+   ↓
+2. Query Relationships
+   └─ Load command-relationships.json
+   ↓
+3. Find Next Steps
+   ├─ Check next_steps array
+   ├─ Consider prerequisites
+   └─ Check related_commands
+   ↓
+4. Generate Recommendations
+   ├─ Primary recommendation (most common next step)
+   ├─ Alternative options
+   └─ Rationale for each
+   ↓
+5. Add Workflow Context
+   └─ Link to workflow-patterns.md
+```
+
+### Implementation
+
+```javascript
+async function getRecommendations(currentCommand) {
+  // Load relationships
+  const relationships = await readIndex('command-relationships.json');
+
+  // Get relationship data
+  const cmdData = relationships[currentCommand];
+
+  if (!cmdData) {
+    return defaultRecommendations();
+  }
+
+  // Primary next steps
+  const nextSteps = cmdData.next_steps || [];
+
+  // Alternative related commands
+  const alternatives = cmdData.related_commands || [];
+
+  // Build recommendations
+  const recommendations = {
+    primary: await enrichCommand(nextSteps[0]),
+    alternatives: await enrichCommands(alternatives),
+    workflow_pattern: findWorkflowPattern(currentCommand),
+    rationale: generateRationale(currentCommand, nextSteps[0])
+  };
+
+  return recommendations;
+}
+```
+
+---
+
+## Mode 3: Full Documentation 📖
+
+### Trigger Analysis
+
+**Keywords**: 参数, 怎么用, 如何使用, [command] 详情
+
+**Examples**:
+- "/workflow:plan 的参数是什么？"
+- "如何使用 /cli:execute？"
+- "task:create 详细文档"
+
+### Processing Flow
+
+```
+1. Extract Command Name
+   └─ Parse /workflow:plan or workflow:plan
+   ↓
+2. Locate in Index
+   └─ Search all-commands.json
+   ↓
+3. Read Full Command File
+   └─ Use file_path from index
+   ↓
+4. Extract Documentation
+   ├─ Parameters section
+   ├─ Arguments specification
+   ├─ Examples section
+   └─ Best practices
+   ↓
+5. Format Response
+   ├─ Command overview
+   ├─ Full parameter list
+   ├─ Usage examples
+   └─ Related commands
+```
+
+### Implementation
+
+```javascript
+async function getDocumentation(commandName) {
+  // Normalize command name
+  const normalized = normalizeCommandName(commandName);
+
+  // Find in index
+  const allCommands = await readIndex('all-commands.json');
+  const command = allCommands.find(cmd => cmd.name === normalized);
+
+  if (!command) {
+    return { error: 'Command not found' };
+  }
+
+  // Read full command file
+  const commandFilePath = path.join(
+    '../commands',
+    command.file_path
+  );
+  const fullDoc = await readCommandFile(commandFilePath);
+
+  // Parse sections
+  const documentation = {
+    name: command.name,
+    description: command.description,
+    arguments: command.arguments,
+    difficulty: command.difficulty,
+    usage_scenario: command.usage_scenario,
+    parameters: extractSection(fullDoc, '## Parameters'),
+    examples: extractSection(fullDoc, '## Examples'),
+    best_practices: extractSection(fullDoc, '## Best Practices'),
+    related: await getRelatedCommands(command.name)
+  };
+
+  return documentation;
+}
+```
+
+---
+
+## Mode 4: Beginner Onboarding 🎓
+
+### Trigger Analysis
+
+**Keywords**: 新手, 入门, getting started, 常用命令, 如何开始
+
+**Examples**:
+- "我是新手，如何开始？"
+- "getting started with workflows"
+- "最常用的命令有哪些？"
+
+### Processing Flow
+
+```
+1. Assess User Level
+   └─ Identify as beginner
+   ↓
+2. Load Essential Commands
+   └─ Read essential-commands.json
+   ↓
+3. Build Learning Path
+   ├─ Step 1: Core commands (Top 5)
+   ├─ Step 2: Basic workflow
+   ├─ Step 3: Intermediate commands
+   └─ Step 4: Advanced features
+   ↓
+4. Provide Resources
+   ├─ Link to getting-started.md
+   ├─ Link to workflow-patterns.md
+   └─ Suggest first task
+   ↓
+5. Interactive Guidance
+   └─ Offer to walk through first workflow
+```
+
+### Implementation
+
+```javascript
+async function onboardBeginner() {
+  // Load essential commands
+  const essentialCommands = await readIndex('essential-commands.json');
+
+  // Group by difficulty
+  const beginner = essentialCommands.filter(cmd =>
+    cmd.difficulty === 'Beginner' || cmd.difficulty === 'Intermediate'
+  );
+
+  // Create learning path
+  const learningPath = {
+    step1: {
+      title: 'Core Commands (Start Here)',
+      commands: beginner.slice(0, 5),
+      guide: 'guides/getting-started.md'
+    },
+    step2: {
+      title: 'Your First Workflow',
+      pattern: 'Plan → Execute',
+      commands: ['workflow:plan', 'workflow:execute'],
+      guide: 'guides/workflow-patterns.md#basic-workflow'
+    },
+    step3: {
+      title: 'Intermediate Skills',
+      commands: beginner.slice(5, 10),
+      guide: 'guides/workflow-patterns.md#common-patterns'
+    }
+  };
+
+  // Resources
+  const resources = {
+    getting_started: 'guides/getting-started.md',
+    workflow_patterns: 'guides/workflow-patterns.md',
+    cli_tools: 'guides/cli-tools-guide.md',
+    troubleshooting: 'guides/troubleshooting.md'
+  };
+
+  return {
+    learning_path: learningPath,
+    resources: resources,
+    first_task: 'Try: /workflow:plan "create a simple feature"'
+  };
+}
+```
+
+---
+
+## Mode 5: Issue Reporting 📝
+
+### Trigger Analysis
+
+**Keywords**: CCW-issue, CCW-help, 报告 bug, 功能建议, 问题咨询
+
+**Examples**:
+- "CCW-issue"
+- "我要报告一个 bug"
+- "CCW-help 有问题"
+- "想提个功能建议"
+
+### Processing Flow
+
+```
+1. Detect Issue Type
+   └─ Use AskUserQuestion if unclear
+   ↓
+2. Select Template
+   ├─ Bug → templates/issue-bug.md
+   ├─ Feature → templates/issue-feature.md
+   └─ Question → templates/issue-question.md
+   ↓
+3. Collect Information
+   └─ Interactive Q&A
+      ├─ Problem description
+      ├─ Steps to reproduce (bug)
+      ├─ Expected vs actual (bug)
+      ├─ Use case (feature)
+      └─ Context
+   ↓
+4. Generate Filled Template
+   └─ Populate template with collected data
+   ↓
+5. Save or Display
+   ├─ Save to templates/.generated/
+   └─ Display for user to copy
+```
+
+### Implementation
+
+```javascript
+async function reportIssue(issueType) {
+  // Determine type (bug/feature/question)
+  if (!issueType) {
+    issueType = await askUserQuestion({
+      question: 'What type of issue would you like to report?',
+      options: ['Bug Report', 'Feature Request', 'Question']
+    });
+  }
+
+  // Select template
+  const templatePath = {
+    'bug': 'templates/issue-bug.md',
+    'feature': 'templates/issue-feature.md',
+    'question': 'templates/issue-question.md'
+  }[issueType.toLowerCase()];
+
+  const template = await readTemplate(templatePath);
+
+  // Collect information
+  const info = await collectIssueInfo(issueType);
+
+  // Fill template
+  const filledTemplate = fillTemplate(template, {
+    ...info,
+    timestamp: new Date().toISOString(),
+    auto_context: gatherAutoContext()
+  });
+
+  // Save
+  const outputPath = `templates/.generated/${issueType}-${Date.now()}.md`;
+  await writeFile(outputPath, filledTemplate);
+
+  return {
+    template: filledTemplate,
+    file_path: outputPath,
+    instructions: 'Copy content to GitHub Issues or use: gh issue create -F ' + outputPath
+  };
+}
+```
+
+---
+
+## Error Handling
+
+### Not Found
+```javascript
+if (results.length === 0) {
+  return {
+    message: 'No commands found matching your query.',
+    suggestions: [
+      'Try broader keywords',
+      'Browse by category: workflow, cli, memory, task',
+      'View all commands: essential-commands.json',
+      'Need help? Ask: "CCW-help"'
+    ]
+  };
+}
+```
+
+### Ambiguous Intent
+```javascript
+if (intent === 'CLARIFY') {
+  return await askUserQuestion({
+    question: 'What would you like to do?',
+    options: [
+      'Search for commands',
+      'Get recommendations for next steps',
+      'View command documentation',
+      'Learn how to get started',
+      'Report an issue or get help'
+    ]
+  });
+}
+```
+
+---
+
+## Optimization Strategies
+
+### Caching
+```javascript
+// Cache indexes in memory after first load
+const indexCache = new Map();
+
+async function readIndex(filename) {
+  if (indexCache.has(filename)) {
+    return indexCache.get(filename);
+  }
+
+  const data = await readFile(`index/${filename}`);
+  const parsed = JSON.parse(data);
+  indexCache.set(filename, parsed);
+  return parsed;
+}
+```
+
+### Lazy Loading
+```javascript
+// Only load full command files when needed
+// Use index metadata for most queries
+// Read command file only for Mode 3 (Documentation)
+```
+
+---
+
+**Last Updated**: 2025-01-06

.claude/skills/command-guide/guides/index-structure.md

@@ -0,0 +1,326 @@
+# Index Structure Reference
+
+Complete documentation for command index files and their data structures.
+
+## Overview
+
+The command-guide skill uses 5 JSON index files to organize and query 69 commands across the Claude DMS3 workflow system.
+
+## Index Files
+
+### 1. `all-commands.json`
+
+**Purpose**: Complete catalog of all commands with full metadata
+
+**Use Cases**:
+- Full-text search across all commands
+- Detailed command queries
+- Batch operations
+- Reference lookup
+
+**Structure**:
+```json
+[
+  {
+    "name": "workflow:plan",
+    "description": "Orchestrate 5-phase planning workflow with quality gate",
+    "arguments": "[--agent] [--cli-execute] \"text description\"|file.md",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "planning",
+    "difficulty": "Advanced",
+    "file_path": "workflow/plan.md"
+  },
+  ...
+]
+```
+
+**Fields**:
+- `name` (string): Command name (e.g., "workflow:plan")
+- `description` (string): Brief functional description
+- `arguments` (string): Parameter specification
+- `category` (string): Primary category (workflow/cli/memory/task)
+- `subcategory` (string|null): Secondary grouping if applicable
+- `usage_scenario` (string): Primary use case (planning/implementation/testing/etc.)
+- `difficulty` (string): Skill level (Beginner/Intermediate/Advanced)
+- `file_path` (string): Relative path to command file
+
+**Total Records**: 69 commands
+
+---
+
+### 2. `by-category.json`
+
+**Purpose**: Hierarchical organization by category and subcategory
+
+**Use Cases**:
+- Browse commands by category
+- Category-specific listings
+- Hierarchical navigation
+- Understanding command organization
+
+**Structure**:
+```json
+{
+  "workflow": {
+    "core": [
+      {
+        "name": "workflow:plan",
+        "description": "...",
+        ...
+      }
+    ],
+    "brainstorm": [...],
+    "session": [...],
+    "tools": [...],
+    "ui-design": [...]
+  },
+  "cli": {
+    "mode": [...],
+    "core": [...]
+  },
+  "memory": [...],
+  "task": [...]
+}
+```
+
+**Category Breakdown**:
+- **workflow** (46 commands):
+  - core: 11 commands
+  - brainstorm: 12 commands
+  - session: 4 commands
+  - tools: 9 commands
+  - ui-design: 10 commands
+- **cli** (9 commands):
+  - mode: 3 commands
+  - core: 6 commands
+- **memory** (8 commands)
+- **task** (4 commands)
+- **general** (2 commands)
+
+---
+
+### 3. `by-use-case.json`
+
+**Purpose**: Commands organized by practical usage scenarios
+
+**Use Cases**:
+- Task-oriented command discovery
+- "I want to do X" queries
+- Workflow planning
+- Learning paths
+
+**Structure**:
+```json
+{
+  "planning": [
+    {
+      "name": "workflow:plan",
+      "description": "...",
+      ...
+    },
+    ...
+  ],
+  "implementation": [...],
+  "testing": [...],
+  "documentation": [...],
+  "session-management": [...],
+  "general": [...]
+}
+```
+
+**Use Case Categories**:
+- **planning**: Architecture, task breakdown, design
+- **implementation**: Coding, development, execution
+- **testing**: Test generation, TDD, quality assurance
+- **documentation**: Docs generation, memory management
+- **session-management**: Workflow control, resumption
+- **general**: Utilities, versioning, prompt enhancement
+
+---
+
+### 4. `essential-commands.json`
+
+**Purpose**: Curated list of 10-15 most frequently used commands
+
+**Use Cases**:
+- Quick reference for beginners
+- Onboarding new users
+- Common workflow starters
+- Cheat sheet
+
+**Structure**:
+```json
+[
+  {
+    "name": "enhance-prompt",
+    "description": "Context-aware prompt enhancement",
+    "arguments": "\"user input to enhance\"",
+    "category": "general",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "file_path": "enhance-prompt.md"
+  },
+  ...
+]
+```
+
+**Selection Criteria**:
+- Frequency of use in common workflows
+- Value for beginners
+- Core functionality coverage
+- Minimal overlap in capabilities
+
+**Current Count**: 14 commands
+
+**List**:
+1. `enhance-prompt` - Prompt enhancement
+2. `version` - Version info
+3. `cli:analyze` - Quick codebase analysis
+4. `cli:chat` - Direct CLI interaction
+5. `cli:execute` - Auto-execution
+6. `cli:mode:plan` - Planning mode
+7. `task:breakdown` - Task decomposition
+8. `task:create` - Create tasks
+9. `task:execute` - Execute tasks
+10. `workflow:execute` - Run workflows
+11. `workflow:plan` - Plan workflows
+12. `workflow:review` - Review implementation
+13. `workflow:tdd-plan` - TDD planning
+14. `workflow:test-gen` - Test generation
+
+---
+
+### 5. `command-relationships.json`
+
+**Purpose**: Mapping of command dependencies and common sequences
+
+**Use Cases**:
+- Next-step recommendations
+- Workflow pattern suggestions
+- Related command discovery
+- Smart navigation
+
+**Structure**:
+```json
+{
+  "workflow:plan": {
+    "related_commands": [
+      "workflow:execute",
+      "workflow:action-plan-verify"
+    ],
+    "next_steps": ["workflow:execute"],
+    "prerequisites": []
+  },
+  "workflow:execute": {
+    "related_commands": [
+      "workflow:status",
+      "workflow:resume",
+      "workflow:review"
+    ],
+    "next_steps": ["workflow:review", "workflow:status"],
+    "prerequisites": ["workflow:plan"]
+  },
+  ...
+}
+```
+
+**Fields**:
+- `related_commands` (array): Commonly used together
+- `next_steps` (array): Typical next commands
+- `prerequisites` (array): Usually run before this command
+
+**Relationship Types**:
+1. **Sequential**: A → B (plan → execute)
+2. **Alternatives**: A | B (execute OR codex-execute)
+3. **Built-in**: A includes B (plan auto-includes context-gather)
+
+---
+
+## Query Patterns
+
+### Pattern 1: Keyword Search
+```javascript
+// Search by keyword in name or description
+const results = allCommands.filter(cmd =>
+  cmd.name.includes(keyword) ||
+  cmd.description.toLowerCase().includes(keyword.toLowerCase())
+);
+```
+
+### Pattern 2: Category Browse
+```javascript
+// Get all commands in a category
+const workflowCommands = byCategory.workflow;
+const coreWorkflow = byCategory.workflow.core;
+```
+
+### Pattern 3: Use-Case Lookup
+```javascript
+// Find commands for specific use case
+const planningCommands = byUseCase.planning;
+```
+
+### Pattern 4: Related Commands
+```javascript
+// Get next steps after a command
+const nextSteps = commandRelationships["workflow:plan"].next_steps;
+```
+
+### Pattern 5: Essential Commands
+```javascript
+// Get beginner-friendly quick reference
+const quickStart = essentialCommands;
+```
+
+---
+
+## Maintenance
+
+### Regenerating Indexes
+
+When commands are added/modified/removed:
+
+```bash
+bash scripts/update-index.sh
+```
+
+The script will:
+1. Scan all .md files in commands/
+2. Extract metadata from YAML frontmatter
+3. Analyze command relationships
+4. Identify essential commands
+5. Generate all 5 index files
+
+### Validation Checklist
+
+After regeneration, verify:
+- [ ] All 5 JSON files are valid (no syntax errors)
+- [ ] Total command count matches (currently 69)
+- [ ] No missing fields in records
+- [ ] Category breakdown correct
+- [ ] Essential commands reasonable (10-15)
+- [ ] Relationships make logical sense
+
+---
+
+## Performance Considerations
+
+**Index Sizes**:
+- `all-commands.json`: ~28KB
+- `by-category.json`: ~31KB
+- `by-use-case.json`: ~29KB
+- `command-relationships.json`: ~7KB
+- `essential-commands.json`: ~5KB
+
+**Total**: ~100KB (fast to load)
+
+**Query Speed**:
+- In-memory search: < 1ms
+- File read + parse: < 50ms
+- Recommended: Load indexes once, cache in memory
+
+---
+
+**Last Updated**: 2025-01-06

.claude/skills/command-guide/guides/troubleshooting.md

@@ -0,0 +1,92 @@
+# 常见问题与解决方案
+
+在使用 Gemini CLI 的过程中，您可能会遇到一些问题。本指南旨在帮助您诊断和解决这些常见问题，确保您能顺利使用 CLI。
+
+## 1. 命令执行失败或未找到
+
+**问题描述**:
+- 您输入的命令没有响应，或者系统提示“命令未找到”。
+- 命令执行后出现错误信息，但您不理解其含义。
+
+**可能原因**:
+- 命令拼写错误。
+- CLI 未正确安装或环境变量配置不正确。
+- 命令所需的依赖项缺失。
+- 命令参数不正确或缺失。
+
+**解决方案**:
+1.  **检查拼写**: 仔细核对您输入的命令是否正确，包括命令名称和任何参数。
+2.  **查看帮助**: 使用 `gemini help` 或 `gemini [command-name] --help` 来查看命令的正确用法、可用参数和示例。
+3.  **验证安装**: 确保 Gemini CLI 已正确安装，并且其可执行文件路径已添加到系统的环境变量中。您可以尝试重新安装 CLI。
+4.  **检查日志**: CLI 通常会生成日志文件。查看这些日志可以提供更详细的错误信息，帮助您定位问题。
+5.  **更新 CLI**: 确保您使用的是最新版本的 Gemini CLI。旧版本可能存在已知错误，通过 `gemini version` 检查并更新。
+
+## 2. 权限问题
+
+**问题描述**:
+- CLI 尝试读取、写入或创建文件/目录时，提示“权限被拒绝”或类似错误。
+- 某些操作（如安装依赖、修改系统配置）失败。
+
+**可能原因**:
+- 当前用户没有足够的权限执行该操作。
+- 文件或目录被其他程序占用。
+
+**解决方案**:
+1.  **以管理员身份运行**: 尝试以管理员权限（Windows）或使用 `sudo`（Linux/macOS）运行您的终端或命令提示符。
+    ```bash
+    # Windows (在命令提示符或 PowerShell 中右键选择“以管理员身份运行”)
+    # Linux/macOS
+    sudo gemini [command]
+    ```
+2.  **检查文件/目录权限**: 确保您对目标文件或目录拥有读/写/执行权限。您可能需要使用 `chmod` (Linux/macOS) 或修改文件属性 (Windows) 来更改权限。
+3.  **关闭占用程序**: 确保没有其他程序正在使用您尝试访问的文件或目录。
+
+## 3. 配置问题
+
+**问题描述**:
+- CLI 行为异常，例如无法连接到 LLM 服务，或者某些功能无法正常工作。
+- 提示缺少 API 密钥或配置项。
+
+**可能原因**:
+- 配置文件（如 `.gemini.json` 或相关环境变量）设置不正确。
+- API 密钥过期或无效。
+- 网络连接问题导致无法访问外部服务。
+
+**解决方案**:
+1.  **检查配置文件**: 仔细检查 Gemini CLI 的配置文件（通常位于用户主目录或项目根目录）中的设置。确保所有路径、API 密钥和选项都正确无误。
+2.  **验证环境变量**: 确认所有必要的环境变量（如 `GEMINI_API_KEY`）都已正确设置。
+3.  **网络连接**: 检查您的网络连接是否正常，并确保没有防火墙或代理设置阻止 CLI 访问外部服务。
+4.  **重新初始化配置**: 对于某些配置问题，您可能需要使用 `gemini cli-init` 命令重新初始化 CLI 配置。
+    ```bash
+    gemini cli-init
+    ```
+
+## 4. 智能代理 (LLM) 相关问题
+
+**问题描述**:
+- 智能代理的响应质量不佳，不相关或不准确。
+- 代理响应速度慢，或提示达到速率限制。
+
+**可能原因**:
+- 提示不够清晰或缺乏上下文。
+- 选择了不适合当前任务的 LLM 模型。
+- LLM 服务提供商的速率限制或服务中断。
+
+**解决方案**:
+1.  **优化提示**: 尝试使用 `enhance-prompt` 命令来优化您的输入，提供更清晰、更具体的上下文信息。
+2.  **选择合适的工具**: 根据任务类型，使用 `--tool` 标志选择最合适的 LLM 模型（如 `codex` 适用于代码生成，`gemini` 适用于复杂推理）。
+    ```bash
+    gemini analyze --tool gemini "分析这个复杂算法"
+    ```
+3.  **检查 API 密钥和配额**: 确保您的 LLM 服务 API 密钥有效，并且没有超出使用配额。
+4.  **重试或等待**: 如果是速率限制或服务中断，请稍后重试或联系服务提供商。
+
+## 5. 寻求帮助
+
+如果以上解决方案都无法解决您的问题，您可以：
+
+-   **查阅官方文档**: 访问 Gemini CLI 的官方文档获取更全面的信息。
+-   **社区支持**: 在相关的开发者社区或论坛中提问。
+-   **提交问题**: 如果您认为是 CLI 的 bug，请在项目的问题跟踪器中提交详细的问题报告。
+
+希望本指南能帮助您解决遇到的问题，让您更好地利用 Gemini CLI！

.claude/skills/command-guide/guides/workflow-patterns.md

@@ -0,0 +1,100 @@
+# 常见工作流模式
+
+Gemini CLI 不仅提供单个命令，更能通过智能编排将一系列命令组合成强大的工作流，帮助您高效完成复杂任务。本指南将介绍几种常见的工作流模式。
+
+## 1. 工作流核心概念
+
+在深入了解具体模式之前，理解工作流的架构至关重要。Gemini CLI 的工作流管理系统旨在提供一个灵活、可扩展的框架，用于定义、执行和协调复杂的开发任务。
+
+- **工作流 (Workflows)**：一系列任务的组合，旨在实现特定的开发目标。
+- **任务 (Tasks)**：工作流中的独立工作单元，可以简单也可以复杂，有状态、输入和输出。
+- **智能体 (Agents)**：通常由大型语言模型驱动，负责执行任务或在工作流中做出决策。
+- **上下文 (Context)**：当前工作流的相关动态信息，包括项目状态、代码片段、文档、用户输入等，是智能决策的关键。
+- **记忆 (Memory)**：持久存储上下文、工作流历史和学习模式，支持工作流的恢复、适应和改进。
+
+详情可参考 `../../workflows/workflow-architecture.md`。
+
+## 2. 规划 -> 执行 (Plan -> Execute) 模式
+
+这是最基础也是最常用的工作流模式，它将一个大的目标分解为可执行的步骤，并逐步实现。
+
+**场景**: 您有一个需要从头开始实现的新功能或模块。
+
+**主要命令**: 
+- `plan`: 启动高级规划过程，分解目标。
+- `breakdown`: 进一步细化和分解 `plan` 生成的任务。
+- `create`: 创建具体的实施任务。
+- `execute`: 执行创建好的任务以实现代码或解决方案。
+
+**工作流示例**:
+1.  **启动规划**: `gemini plan "开发一个用户认证服务"`
+    - CLI 会与您互动，明确需求，并生成一个初步的规划（可能包含多个子任务）。
+2.  **任务分解** (可选，如果规划足够细致可跳过):
+    - 假设 `plan` 产生了一个任务 ID `task-auth-service`。
+    - `gemini breakdown task-auth-service`
+    - 可能进一步分解为 `task-register`, `task-login`, `task-password-reset`等。
+3.  **创建具体实现任务**:
+    - `gemini create "实现用户注册 API 接口"`
+    - 这会生成一个专门针对此任务的 ID，例如 `task-id-register-api`。
+4.  **执行实现任务**:
+    - `gemini execute task-id-register-api`
+    - CLI 将调用智能体自动编写和集成代码。
+
+## 3. 测试驱动开发 (TDD) 模式
+
+TDD 模式强调先编写测试，再编写满足测试的代码，然后重构。Gemini CLI 通过自动化 TDD 流程来支持这一模式。
+
+**场景**: 您正在开发一个新功能，并希望通过 TDD 确保代码质量和正确性。
+
+**主要命令**:
+- `tdd-plan`: 规划 TDD 工作流，生成红-绿-重构任务链。
+- `test-gen`: 根据功能描述生成测试用例。
+- `execute`: 执行代码生成和测试。
+- `tdd-verify`: 验证 TDD 工作流的合规性并生成质量报告。
+
+**工作流示例**:
+1.  **TDD 规划**: `gemini tdd-plan "实现一个购物车功能"`
+    - CLI 将为您创建一个 TDD 任务链，包括测试生成、代码实现和验证。
+2.  **生成测试**: (通常包含在 `tdd-plan` 的早期阶段，或可以单独调用)
+    - `gemini test-gen source-session-id` (如果已有一个实现会话)
+    - 这会产生失败的测试（红）。
+3.  **执行代码实现和测试**: 
+    - `gemini execute task-id-for-code-implementation`
+    - 智能体会编写代码以通过测试，并将执行测试（变为绿）。
+4.  **TDD 验证**: `gemini tdd-verify`
+    - 验证整个 TDD 周期是否规范执行，以及生成测试覆盖率等报告。
+
+## 4. UI 设计与实现工作流
+
+Gemini CLI 可以辅助您进行 UI 的设计、提取和代码生成，加速前端开发。
+
+**场景**: 您需要基于一些设计稿或现有网站来快速构建 UI 原型或实现页面。
+
+**主要命令**:
+- `ui-designer`: 启动 UI 设计分析。
+- `layout-extract`: 从参考图像或 URL 提取布局信息。
+- `style-extract`: 从参考图像或 URL 提取设计风格。
+- `generate`: 组合布局和设计令牌生成 UI 原型。
+- `update`: 使用最终设计系统参考更新设计产物。
+
+**工作流示例**:
+1.  **启动 UI 设计分析**: `gemini ui-designer`
+    - 开始一个引导式的流程，定义您的 UI 设计目标。
+2.  **提取布局**: `gemini layout-extract --urls "https://example.com/some-page"`
+    - 从给定 URL 提取页面布局结构。
+3.  **提取样式**: `gemini style-extract --images "./design-mockup.png"`
+    - 从设计图中提取颜色、字体等视觉风格。
+4.  **生成 UI 原型**: `gemini generate --base-path ./my-ui-project`
+    - 结合提取的布局和样式，生成可工作的 UI 代码或原型。
+5.  **更新与迭代**: `gemini update --session ui-design-session-id --selected-prototypes "proto-01,proto-03"`
+    - 根据反馈和最终设计系统，迭代并更新生成的 UI 产物。
+
+## 5. 上下文搜索策略
+
+所有这些工作流都依赖于高效的上下文管理。Gemini CLI 采用多层次的上下文搜索策略，以确保智能代理获得最相关的信息。
+
+- **相关性优先**: 优先收集与当前任务直接相关的上下文，而非大量数据。
+- **分层搜索**: 从最直接的来源（如当前打开文件）开始，逐步扩展到项目文件、记忆库和外部资源。
+- **语义理解**: 利用智能搜索理解查询的意图，而非仅仅是关键词匹配。
+
+更多细节请查阅 `../../workflows/context-search-strategy.md`。

.claude/skills/command-guide/index/all-commands.json

@@ -0,0 +1,692 @@
+[
+  {
+    "name": "cli:analyze",
+    "description": "Read-only codebase analysis using Gemini (default), Qwen, or Codex with auto-pattern detection and template selection",
+    "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] analysis target",
+    "category": "cli",
+    "subcategory": "core",
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "file_path": "cli/analyze.md"
+  },
+  {
+    "name": "cli:chat",
+    "description": "Read-only Q&A interaction with Gemini/Qwen/Codex for codebase questions with automatic context inference",
+    "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] inquiry",
+    "category": "cli",
+    "subcategory": "core",
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "file_path": "cli/chat.md"
+  },
+  {
+    "name": "cli:cli-init",
+    "description": "Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection",
+    "arguments": "[--tool gemini|qwen|all] [--output path] [--preview]",
+    "category": "cli",
+    "subcategory": "core",
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "file_path": "cli/cli-init.md"
+  },
+  {
+    "name": "cli:codex-execute",
+    "description": "Multi-stage Codex execution with automatic task decomposition into grouped subtasks using resume mechanism for context continuity",
+    "arguments": "[--verify-git] task description or task-id",
+    "category": "cli",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "cli/codex-execute.md"
+  },
+  {
+    "name": "cli:discuss-plan",
+    "description": "Multi-round collaborative planning using Gemini, Codex, and Claude synthesis with iterative discussion cycles (read-only, no code changes)",
+    "arguments": "[--topic '...'] [--task-id '...'] [--rounds N]",
+    "category": "cli",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "cli/discuss-plan.md"
+  },
+  {
+    "name": "cli:execute",
+    "description": "Autonomous code implementation with YOLO auto-approval using Gemini/Qwen/Codex, supports task ID or description input with automatic file pattern detection",
+    "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] description or task-id",
+    "category": "cli",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "cli/execute.md"
+  },
+  {
+    "name": "cli:mode:bug-diagnosis",
+    "description": "Read-only bug root cause analysis using Gemini/Qwen/Codex with systematic diagnosis template for fix suggestions",
+    "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] bug description",
+    "category": "cli",
+    "subcategory": "mode",
+    "usage_scenario": "analysis",
+    "difficulty": "Intermediate",
+    "file_path": "cli/mode/bug-diagnosis.md"
+  },
+  {
+    "name": "cli:mode:code-analysis",
+    "description": "Read-only execution path tracing using Gemini/Qwen/Codex with specialized analysis template for call flow and optimization",
+    "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] analysis target",
+    "category": "cli",
+    "subcategory": "mode",
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "file_path": "cli/mode/code-analysis.md"
+  },
+  {
+    "name": "cli:mode:plan",
+    "description": "Read-only architecture planning using Gemini/Qwen/Codex with strategic planning template for modification plans and impact analysis",
+    "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] topic",
+    "category": "cli",
+    "subcategory": "mode",
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "file_path": "cli/mode/plan.md"
+  },
+  {
+    "name": "enhance-prompt",
+    "description": "Enhanced prompt transformation using session memory and codebase analysis with --enhance flag detection",
+    "arguments": "user input to enhance",
+    "category": "general",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "enhance-prompt.md"
+  },
+  {
+    "name": "memory:docs",
+    "description": "Plan documentation workflow with dynamic grouping (≤10 docs/task), generates IMPL tasks for parallel module trees, README, ARCHITECTURE, and HTTP API docs",
+    "arguments": "[path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]",
+    "category": "memory",
+    "subcategory": "core",
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "file_path": "memory/docs.md"
+  },
+  {
+    "name": "memory:load-skill-memory",
+    "description": "Activate SKILL package (auto-detect from paths/keywords or manual) and intelligently load documentation based on task intent keywords",
+    "arguments": "[skill_name] \\\"task intent description\\\"",
+    "category": "memory",
+    "subcategory": "core",
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "file_path": "memory/load-skill-memory.md"
+  },
+  {
+    "name": "memory:load",
+    "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
+    "arguments": "[--tool gemini|qwen] \\\"task context description\\\"",
+    "category": "memory",
+    "subcategory": "core",
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "file_path": "memory/load.md"
+  },
+  {
+    "name": "memory:skill-memory",
+    "description": "4-phase autonomous orchestrator: check docs → /memory:docs planning → /workflow:execute → generate SKILL.md with progressive loading index (skips phases 2-3 if docs exist)",
+    "arguments": "[path] [--tool <gemini|qwen|codex>] [--regenerate] [--mode <full|partial>] [--cli-execute]",
+    "category": "memory",
+    "subcategory": "core",
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "file_path": "memory/skill-memory.md"
+  },
+  {
+    "name": "memory:tech-research",
+    "description": "3-phase orchestrator: extract tech stack from session/name → delegate to agent for Exa research and module generation → generate SKILL.md index (skips phase 2 if exists)",
+    "arguments": "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]",
+    "category": "memory",
+    "subcategory": "core",
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "file_path": "memory/tech-research.md"
+  },
+  {
+    "name": "memory:update-full",
+    "description": "Update all CLAUDE.md files using layer-based execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
+    "arguments": "[--tool gemini|qwen|codex] [--path <directory>]",
+    "category": "memory",
+    "subcategory": "core",
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "file_path": "memory/update-full.md"
+  },
+  {
+    "name": "memory:update-related",
+    "description": "Update CLAUDE.md for git-changed modules using batched agent execution (4 modules/agent) with gemini→qwen→codex fallback, <15 modules uses direct execution",
+    "arguments": "[--tool gemini|qwen|codex]",
+    "category": "memory",
+    "subcategory": "core",
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "file_path": "memory/update-related.md"
+  },
+  {
+    "name": "memory:workflow-skill-memory",
+    "description": "Process WFS-* archived sessions using universal-executor agents with Gemini analysis to generate workflow-progress SKILL package (sessions-timeline, lessons, conflicts)",
+    "arguments": "session <session-id> | all",
+    "category": "memory",
+    "subcategory": "core",
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "file_path": "memory/workflow-skill-memory.md"
+  },
+  {
+    "name": "task:breakdown",
+    "description": "Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order",
+    "arguments": "task-id",
+    "category": "task",
+    "subcategory": "core",
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "file_path": "task/breakdown.md"
+  },
+  {
+    "name": "task:create",
+    "description": "Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis",
+    "arguments": "\\\"task title\\\"",
+    "category": "task",
+    "subcategory": "core",
+    "usage_scenario": "testing",
+    "difficulty": "Intermediate",
+    "file_path": "task/create.md"
+  },
+  {
+    "name": "task:execute",
+    "description": "Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking",
+    "arguments": "task-id",
+    "category": "task",
+    "subcategory": "core",
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "file_path": "task/execute.md"
+  },
+  {
+    "name": "task:replan",
+    "description": "Update task JSON with new requirements or batch-update multiple tasks from verification report, tracks changes in task-changes.json",
+    "arguments": "task-id [\\\"text\\\"|file.md] | --batch [verification-report.md]",
+    "category": "task",
+    "subcategory": "core",
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "file_path": "task/replan.md"
+  },
+  {
+    "name": "version",
+    "description": "Display Claude Code version information and check for updates",
+    "arguments": "",
+    "category": "general",
+    "subcategory": "core",
+    "usage_scenario": "utilities",
+    "difficulty": "Basic",
+    "file_path": "version.md"
+  },
+  {
+    "name": "workflow:action-plan-verify",
+    "description": "Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation",
+    "arguments": "[optional: --session session-id]",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/action-plan-verify.md"
+  },
+  {
+    "name": "workflow:brainstorm:api-designer",
+    "description": "Generate or update api-designer/analysis.md addressing guidance-specification discussion points for API design perspective",
+    "arguments": "optional topic - uses existing framework if available",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "session-management",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/api-designer.md"
+  },
+  {
+    "name": "workflow:brainstorm:artifacts",
+    "description": "Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis",
+    "arguments": "topic or challenge description [--count N]",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "session-management",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/artifacts.md"
+  },
+  {
+    "name": "workflow:brainstorm:auto-parallel",
+    "description": "Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives",
+    "arguments": "topic or challenge description\" [--count N]",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "session-management",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/auto-parallel.md"
+  },
+  {
+    "name": "workflow:brainstorm:data-architect",
+    "description": "Generate or update data-architect/analysis.md addressing guidance-specification discussion points for data architecture perspective",
+    "arguments": "optional topic - uses existing framework if available",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "implementation",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/data-architect.md"
+  },
+  {
+    "name": "workflow:brainstorm:product-manager",
+    "description": "Generate or update product-manager/analysis.md addressing guidance-specification discussion points for product management perspective",
+    "arguments": "optional topic - uses existing framework if available",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "implementation",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/product-manager.md"
+  },
+  {
+    "name": "workflow:brainstorm:product-owner",
+    "description": "Generate or update product-owner/analysis.md addressing guidance-specification discussion points for product ownership perspective",
+    "arguments": "optional topic - uses existing framework if available",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "implementation",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/product-owner.md"
+  },
+  {
+    "name": "workflow:brainstorm:scrum-master",
+    "description": "Generate or update scrum-master/analysis.md addressing guidance-specification discussion points for Agile process perspective",
+    "arguments": "optional topic - uses existing framework if available",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "planning",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/scrum-master.md"
+  },
+  {
+    "name": "workflow:brainstorm:subject-matter-expert",
+    "description": "Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points for domain expertise perspective",
+    "arguments": "optional topic - uses existing framework if available",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "implementation",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/subject-matter-expert.md"
+  },
+  {
+    "name": "workflow:brainstorm:synthesis",
+    "description": "Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent",
+    "arguments": "[optional: --session session-id]",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "brainstorming",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/synthesis.md"
+  },
+  {
+    "name": "workflow:brainstorm:system-architect",
+    "description": "Generate or update system-architect/analysis.md addressing guidance-specification discussion points for system architecture perspective",
+    "arguments": "optional topic - uses existing framework if available",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "session-management",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/system-architect.md"
+  },
+  {
+    "name": "workflow:brainstorm:ui-designer",
+    "description": "Generate or update ui-designer/analysis.md addressing guidance-specification discussion points for UI design perspective",
+    "arguments": "optional topic - uses existing framework if available",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "planning",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/ui-designer.md"
+  },
+  {
+    "name": "workflow:brainstorm:ux-expert",
+    "description": "Generate or update ux-expert/analysis.md addressing guidance-specification discussion points for UX perspective",
+    "arguments": "optional topic - uses existing framework if available",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "implementation",
+    "difficulty": "Advanced",
+    "file_path": "workflow/brainstorm/ux-expert.md"
+  },
+  {
+    "name": "workflow:execute",
+    "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
+    "arguments": "[--resume-session=\\\"session-id\\\"]",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/execute.md"
+  },
+  {
+    "name": "workflow:plan",
+    "description": "5-phase planning workflow with Gemini analysis and action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs with optional CLI auto-execution",
+    "arguments": "[--agent] [--cli-execute] \\\"text description\\\"|file.md",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/plan.md"
+  },
+  {
+    "name": "workflow:resume",
+    "description": "Resume paused workflow session with automatic progress analysis, pending task identification, and conflict detection",
+    "arguments": "session-id for workflow session to resume",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/resume.md"
+  },
+  {
+    "name": "workflow:review",
+    "description": "Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini",
+    "arguments": "[--type=security|architecture|action-items|quality] [optional: session-id]",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "testing",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/review.md"
+  },
+  {
+    "name": "workflow:session:complete",
+    "description": "Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag",
+    "arguments": "# Complete current active session",
+    "category": "workflow",
+    "subcategory": "session",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/session/complete.md"
+  },
+  {
+    "name": "workflow:session:list",
+    "description": "List all workflow sessions with status filtering, shows session metadata and progress information",
+    "arguments": "# Show all sessions with status",
+    "category": "workflow",
+    "subcategory": "session",
+    "usage_scenario": "session-management",
+    "difficulty": "Basic",
+    "file_path": "workflow/session/list.md"
+  },
+  {
+    "name": "workflow:session:resume",
+    "description": "Resume the most recently paused workflow session with automatic session discovery and status update",
+    "arguments": "# Resume most recent paused session",
+    "category": "workflow",
+    "subcategory": "session",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/session/resume.md"
+  },
+  {
+    "name": "workflow:session:start",
+    "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
+    "arguments": "[--auto|--new] [optional: task description for new session]",
+    "category": "workflow",
+    "subcategory": "session",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/session/start.md"
+  },
+  {
+    "name": "workflow:status",
+    "description": "Generate on-demand task status views from JSON task data with optional task-id filtering for detailed view",
+    "arguments": "[optional: task-id]",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "monitoring",
+    "difficulty": "Basic",
+    "file_path": "workflow/status.md"
+  },
+  {
+    "name": "workflow:tdd-plan",
+    "description": "TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking",
+    "arguments": "[--agent] \\\"feature description\\\"|file.md",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/tdd-plan.md"
+  },
+  {
+    "name": "workflow:tdd-verify",
+    "description": "Verify TDD workflow compliance against Red-Green-Refactor cycles, generate quality report with coverage analysis",
+    "arguments": "[optional: WFS-session-id]",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/tdd-verify.md"
+  },
+  {
+    "name": "workflow:test-cycle-execute",
+    "description": "Execute test-fix workflow with dynamic task generation and iterative fix cycles until all tests pass or max iterations reached",
+    "arguments": "[--resume-session=\\\"session-id\\\"] [--max-iterations=N]",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/test-cycle-execute.md"
+  },
+  {
+    "name": "workflow:test-fix-gen",
+    "description": "Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning",
+    "arguments": "[--use-codex] [--cli-execute] (source-session-id | \\\"feature description\\\" | /path/to/file.md)",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "testing",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/test-fix-gen.md"
+  },
+  {
+    "name": "workflow:test-gen",
+    "description": "Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks",
+    "arguments": "[--use-codex] [--cli-execute] source-session-id",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "testing",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/test-gen.md"
+  },
+  {
+    "name": "workflow:tools:conflict-resolution",
+    "description": "Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen",
+    "arguments": "--session WFS-session-id --context path/to/context-package.json",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "brainstorming",
+    "difficulty": "Advanced",
+    "file_path": "workflow/tools/conflict-resolution.md"
+  },
+  {
+    "name": "workflow:tools:context-gather",
+    "description": "Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON",
+    "arguments": "--session WFS-session-id \\\"task description\\\"",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "implementation",
+    "difficulty": "Advanced",
+    "file_path": "workflow/tools/context-gather.md"
+  },
+  {
+    "name": "workflow:tools:task-generate-agent",
+    "description": "Autonomous task generation using action-planning-agent with discovery and output phases for workflow planning",
+    "arguments": "--session WFS-session-id [--cli-execute]",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "planning",
+    "difficulty": "Advanced",
+    "file_path": "workflow/tools/task-generate-agent.md"
+  },
+  {
+    "name": "workflow:tools:task-generate-tdd",
+    "description": "Generate TDD task chains with Red-Green-Refactor dependencies, test-first structure, and cycle validation",
+    "arguments": "--session WFS-session-id [--agent]",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "planning",
+    "difficulty": "Advanced",
+    "file_path": "workflow/tools/task-generate-tdd.md"
+  },
+  {
+    "name": "workflow:tools:task-generate",
+    "description": "",
+    "arguments": "--session WFS-auth",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "planning",
+    "difficulty": "Advanced",
+    "file_path": "workflow/tools/task-generate.md"
+  },
+  {
+    "name": "workflow:tools:tdd-coverage-analysis",
+    "description": "Analyze test coverage and TDD cycle execution with Red-Green-Refactor compliance verification",
+    "arguments": "--session WFS-session-id",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "testing",
+    "difficulty": "Advanced",
+    "file_path": "workflow/tools/tdd-coverage-analysis.md"
+  },
+  {
+    "name": "workflow:tools:test-concept-enhanced",
+    "description": "Analyze test requirements and generate test generation strategy using Gemini with test-context package",
+    "arguments": "--session WFS-test-session-id --context path/to/test-context-package.json",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "testing",
+    "difficulty": "Advanced",
+    "file_path": "workflow/tools/test-concept-enhanced.md"
+  },
+  {
+    "name": "workflow:tools:test-context-gather",
+    "description": "Collect test coverage context using test-context-search-agent and package into standardized test-context JSON",
+    "arguments": "--session WFS-test-session-id",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "implementation",
+    "difficulty": "Advanced",
+    "file_path": "workflow/tools/test-context-gather.md"
+  },
+  {
+    "name": "workflow:tools:test-task-generate",
+    "description": "Generate test-fix task JSON with iterative test-fix-retest cycle specification using Gemini/Qwen/Codex",
+    "arguments": "[--use-codex] [--cli-execute] --session WFS-test-session-id",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "session-management",
+    "difficulty": "Advanced",
+    "file_path": "workflow/tools/test-task-generate.md"
+  },
+  {
+    "name": "workflow:ui-design:animation-extract",
+    "description": "Extract animation and transition patterns from URLs, CSS, or interactive questioning for design system documentation",
+    "arguments": "[--base-path <path>] [--session <id>] [--urls \"<list>\"] [--mode <auto|interactive>] [--focus \"<types>\"]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "documentation",
+    "difficulty": "Advanced",
+    "file_path": "workflow/ui-design/animation-extract.md"
+  },
+  {
+    "name": "workflow:ui-design:batch-generate",
+    "description": "Prompt-driven batch UI generation using target-style-centric parallel execution with design token application",
+    "arguments": "[--targets \"<list>\"] [--target-type \"page|component\"] [--device-type \"desktop|mobile|tablet|responsive\"] [--base-path <path>] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "ui-design",
+    "difficulty": "Advanced",
+    "file_path": "workflow/ui-design/batch-generate.md"
+  },
+  {
+    "name": "workflow:ui-design:capture",
+    "description": "Batch screenshot capture for UI design workflows using MCP puppeteer or local fallback with URL mapping",
+    "arguments": "--url-map \"target:url,...\" [--base-path path] [--session id]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "ui-design",
+    "difficulty": "Advanced",
+    "file_path": "workflow/ui-design/capture.md"
+  },
+  {
+    "name": "workflow:ui-design:explore-auto",
+    "description": "Exploratory UI design workflow with style-centric batch generation, creates design variants from prompts/images with parallel execution",
+    "arguments": "[--prompt \"<desc>\"] [--images \"<glob>\"] [--targets \"<list>\"] [--target-type \"page|component\"] [--session <id>] [--style-variants <count>] [--layout-variants <count>] [--batch-plan]\"",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "ui-design",
+    "difficulty": "Advanced",
+    "file_path": "workflow/ui-design/explore-auto.md"
+  },
+  {
+    "name": "workflow:ui-design:explore-layers",
+    "description": "Interactive deep UI capture with depth-controlled layer exploration using MCP puppeteer",
+    "arguments": "--url <url> --depth <1-5> [--session id] [--base-path path]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "ui-design",
+    "difficulty": "Advanced",
+    "file_path": "workflow/ui-design/explore-layers.md"
+  },
+  {
+    "name": "workflow:ui-design:generate",
+    "description": "Assemble UI prototypes by combining layout templates with design tokens, pure assembler without new content generation",
+    "arguments": "[--base-path <path>] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "ui-design",
+    "difficulty": "Advanced",
+    "file_path": "workflow/ui-design/generate.md"
+  },
+  {
+    "name": "workflow:ui-design:imitate-auto",
+    "description": "High-speed multi-page UI replication with batch screenshot capture and design token extraction",
+    "arguments": "--url-map \"<map>\" [--capture-mode <batch|deep>] [--depth <1-5>] [--session <id>] [--prompt \"<desc>\"]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "documentation",
+    "difficulty": "Advanced",
+    "file_path": "workflow/ui-design/imitate-auto.md"
+  },
+  {
+    "name": "workflow:ui-design:layout-extract",
+    "description": "Extract structural layout information from reference images, URLs, or text prompts using Claude analysis",
+    "arguments": "[--base-path <path>] [--session <id>] [--images \"<glob>\"] [--urls \"<list>\"] [--prompt \"<desc>\"] [--targets \"<list>\"] [--mode <imitate|explore>] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "ui-design",
+    "difficulty": "Advanced",
+    "file_path": "workflow/ui-design/layout-extract.md"
+  },
+  {
+    "name": "workflow:ui-design:style-extract",
+    "description": "Extract design style from reference images or text prompts using Claude analysis with variant generation",
+    "arguments": "[--base-path <path>] [--session <id>] [--images \"<glob>\"] [--urls \"<list>\"] [--prompt \"<desc>\"] [--mode <imitate|explore>] [--variants <count>]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "documentation",
+    "difficulty": "Advanced",
+    "file_path": "workflow/ui-design/style-extract.md"
+  },
+  {
+    "name": "workflow:ui-design:update",
+    "description": "Update brainstorming artifacts with finalized design system references from selected prototypes",
+    "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "ui-design",
+    "difficulty": "Advanced",
+    "file_path": "workflow/ui-design/update.md"
+  }
+]

.claude/skills/command-guide/index/by-category.json

@@ -0,0 +1,722 @@
+{
+  "cli": {
+    "core": [
+      {
+        "name": "cli:analyze",
+        "description": "Read-only codebase analysis using Gemini (default), Qwen, or Codex with auto-pattern detection and template selection",
+        "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] analysis target",
+        "category": "cli",
+        "subcategory": "core",
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "file_path": "cli/analyze.md"
+      },
+      {
+        "name": "cli:chat",
+        "description": "Read-only Q&A interaction with Gemini/Qwen/Codex for codebase questions with automatic context inference",
+        "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] inquiry",
+        "category": "cli",
+        "subcategory": "core",
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "file_path": "cli/chat.md"
+      },
+      {
+        "name": "cli:cli-init",
+        "description": "Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection",
+        "arguments": "[--tool gemini|qwen|all] [--output path] [--preview]",
+        "category": "cli",
+        "subcategory": "core",
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "file_path": "cli/cli-init.md"
+      },
+      {
+        "name": "cli:codex-execute",
+        "description": "Multi-stage Codex execution with automatic task decomposition into grouped subtasks using resume mechanism for context continuity",
+        "arguments": "[--verify-git] task description or task-id",
+        "category": "cli",
+        "subcategory": "core",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "cli/codex-execute.md"
+      },
+      {
+        "name": "cli:discuss-plan",
+        "description": "Multi-round collaborative planning using Gemini, Codex, and Claude synthesis with iterative discussion cycles (read-only, no code changes)",
+        "arguments": "[--topic '...'] [--task-id '...'] [--rounds N]",
+        "category": "cli",
+        "subcategory": "core",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "cli/discuss-plan.md"
+      },
+      {
+        "name": "cli:execute",
+        "description": "Autonomous code implementation with YOLO auto-approval using Gemini/Qwen/Codex, supports task ID or description input with automatic file pattern detection",
+        "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] description or task-id",
+        "category": "cli",
+        "subcategory": "core",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "cli/execute.md"
+      }
+    ],
+    "mode": [
+      {
+        "name": "cli:mode:bug-diagnosis",
+        "description": "Read-only bug root cause analysis using Gemini/Qwen/Codex with systematic diagnosis template for fix suggestions",
+        "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] bug description",
+        "category": "cli",
+        "subcategory": "mode",
+        "usage_scenario": "analysis",
+        "difficulty": "Intermediate",
+        "file_path": "cli/mode/bug-diagnosis.md"
+      },
+      {
+        "name": "cli:mode:code-analysis",
+        "description": "Read-only execution path tracing using Gemini/Qwen/Codex with specialized analysis template for call flow and optimization",
+        "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] analysis target",
+        "category": "cli",
+        "subcategory": "mode",
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "file_path": "cli/mode/code-analysis.md"
+      },
+      {
+        "name": "cli:mode:plan",
+        "description": "Read-only architecture planning using Gemini/Qwen/Codex with strategic planning template for modification plans and impact analysis",
+        "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] topic",
+        "category": "cli",
+        "subcategory": "mode",
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "file_path": "cli/mode/plan.md"
+      }
+    ]
+  },
+  "general": {
+    "core": [
+      {
+        "name": "enhance-prompt",
+        "description": "Enhanced prompt transformation using session memory and codebase analysis with --enhance flag detection",
+        "arguments": "user input to enhance",
+        "category": "general",
+        "subcategory": "core",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "enhance-prompt.md"
+      },
+      {
+        "name": "version",
+        "description": "Display Claude Code version information and check for updates",
+        "arguments": "",
+        "category": "general",
+        "subcategory": "core",
+        "usage_scenario": "utilities",
+        "difficulty": "Basic",
+        "file_path": "version.md"
+      }
+    ]
+  },
+  "memory": {
+    "core": [
+      {
+        "name": "memory:docs",
+        "description": "Plan documentation workflow with dynamic grouping (≤10 docs/task), generates IMPL tasks for parallel module trees, README, ARCHITECTURE, and HTTP API docs",
+        "arguments": "[path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]",
+        "category": "memory",
+        "subcategory": "core",
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "file_path": "memory/docs.md"
+      },
+      {
+        "name": "memory:load-skill-memory",
+        "description": "Activate SKILL package (auto-detect from paths/keywords or manual) and intelligently load documentation based on task intent keywords",
+        "arguments": "[skill_name] \\\"task intent description\\\"",
+        "category": "memory",
+        "subcategory": "core",
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "file_path": "memory/load-skill-memory.md"
+      },
+      {
+        "name": "memory:load",
+        "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
+        "arguments": "[--tool gemini|qwen] \\\"task context description\\\"",
+        "category": "memory",
+        "subcategory": "core",
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "file_path": "memory/load.md"
+      },
+      {
+        "name": "memory:skill-memory",
+        "description": "4-phase autonomous orchestrator: check docs → /memory:docs planning → /workflow:execute → generate SKILL.md with progressive loading index (skips phases 2-3 if docs exist)",
+        "arguments": "[path] [--tool <gemini|qwen|codex>] [--regenerate] [--mode <full|partial>] [--cli-execute]",
+        "category": "memory",
+        "subcategory": "core",
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "file_path": "memory/skill-memory.md"
+      },
+      {
+        "name": "memory:tech-research",
+        "description": "3-phase orchestrator: extract tech stack from session/name → delegate to agent for Exa research and module generation → generate SKILL.md index (skips phase 2 if exists)",
+        "arguments": "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]",
+        "category": "memory",
+        "subcategory": "core",
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "file_path": "memory/tech-research.md"
+      },
+      {
+        "name": "memory:update-full",
+        "description": "Update all CLAUDE.md files using layer-based execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
+        "arguments": "[--tool gemini|qwen|codex] [--path <directory>]",
+        "category": "memory",
+        "subcategory": "core",
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "file_path": "memory/update-full.md"
+      },
+      {
+        "name": "memory:update-related",
+        "description": "Update CLAUDE.md for git-changed modules using batched agent execution (4 modules/agent) with gemini→qwen→codex fallback, <15 modules uses direct execution",
+        "arguments": "[--tool gemini|qwen|codex]",
+        "category": "memory",
+        "subcategory": "core",
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "file_path": "memory/update-related.md"
+      },
+      {
+        "name": "memory:workflow-skill-memory",
+        "description": "Process WFS-* archived sessions using universal-executor agents with Gemini analysis to generate workflow-progress SKILL package (sessions-timeline, lessons, conflicts)",
+        "arguments": "session <session-id> | all",
+        "category": "memory",
+        "subcategory": "core",
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "file_path": "memory/workflow-skill-memory.md"
+      }
+    ]
+  },
+  "task": {
+    "core": [
+      {
+        "name": "task:breakdown",
+        "description": "Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order",
+        "arguments": "task-id",
+        "category": "task",
+        "subcategory": "core",
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "file_path": "task/breakdown.md"
+      },
+      {
+        "name": "task:create",
+        "description": "Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis",
+        "arguments": "\\\"task title\\\"",
+        "category": "task",
+        "subcategory": "core",
+        "usage_scenario": "testing",
+        "difficulty": "Intermediate",
+        "file_path": "task/create.md"
+      },
+      {
+        "name": "task:execute",
+        "description": "Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking",
+        "arguments": "task-id",
+        "category": "task",
+        "subcategory": "core",
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "file_path": "task/execute.md"
+      },
+      {
+        "name": "task:replan",
+        "description": "Update task JSON with new requirements or batch-update multiple tasks from verification report, tracks changes in task-changes.json",
+        "arguments": "task-id [\\\"text\\\"|file.md] | --batch [verification-report.md]",
+        "category": "task",
+        "subcategory": "core",
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "file_path": "task/replan.md"
+      }
+    ]
+  },
+  "workflow": {
+    "core": [
+      {
+        "name": "workflow:action-plan-verify",
+        "description": "Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation",
+        "arguments": "[optional: --session session-id]",
+        "category": "workflow",
+        "subcategory": "core",
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/action-plan-verify.md"
+      },
+      {
+        "name": "workflow:execute",
+        "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
+        "arguments": "[--resume-session=\\\"session-id\\\"]",
+        "category": "workflow",
+        "subcategory": "core",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/execute.md"
+      },
+      {
+        "name": "workflow:plan",
+        "description": "5-phase planning workflow with Gemini analysis and action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs with optional CLI auto-execution",
+        "arguments": "[--agent] [--cli-execute] \\\"text description\\\"|file.md",
+        "category": "workflow",
+        "subcategory": "core",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/plan.md"
+      },
+      {
+        "name": "workflow:resume",
+        "description": "Resume paused workflow session with automatic progress analysis, pending task identification, and conflict detection",
+        "arguments": "session-id for workflow session to resume",
+        "category": "workflow",
+        "subcategory": "core",
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/resume.md"
+      },
+      {
+        "name": "workflow:review",
+        "description": "Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini",
+        "arguments": "[--type=security|architecture|action-items|quality] [optional: session-id]",
+        "category": "workflow",
+        "subcategory": "core",
+        "usage_scenario": "testing",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/review.md"
+      },
+      {
+        "name": "workflow:status",
+        "description": "Generate on-demand task status views from JSON task data with optional task-id filtering for detailed view",
+        "arguments": "[optional: task-id]",
+        "category": "workflow",
+        "subcategory": "core",
+        "usage_scenario": "monitoring",
+        "difficulty": "Basic",
+        "file_path": "workflow/status.md"
+      },
+      {
+        "name": "workflow:tdd-plan",
+        "description": "TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking",
+        "arguments": "[--agent] \\\"feature description\\\"|file.md",
+        "category": "workflow",
+        "subcategory": "core",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/tdd-plan.md"
+      },
+      {
+        "name": "workflow:tdd-verify",
+        "description": "Verify TDD workflow compliance against Red-Green-Refactor cycles, generate quality report with coverage analysis",
+        "arguments": "[optional: WFS-session-id]",
+        "category": "workflow",
+        "subcategory": "core",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/tdd-verify.md"
+      },
+      {
+        "name": "workflow:test-cycle-execute",
+        "description": "Execute test-fix workflow with dynamic task generation and iterative fix cycles until all tests pass or max iterations reached",
+        "arguments": "[--resume-session=\\\"session-id\\\"] [--max-iterations=N]",
+        "category": "workflow",
+        "subcategory": "core",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/test-cycle-execute.md"
+      },
+      {
+        "name": "workflow:test-fix-gen",
+        "description": "Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning",
+        "arguments": "[--use-codex] [--cli-execute] (source-session-id | \\\"feature description\\\" | /path/to/file.md)",
+        "category": "workflow",
+        "subcategory": "core",
+        "usage_scenario": "testing",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/test-fix-gen.md"
+      },
+      {
+        "name": "workflow:test-gen",
+        "description": "Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks",
+        "arguments": "[--use-codex] [--cli-execute] source-session-id",
+        "category": "workflow",
+        "subcategory": "core",
+        "usage_scenario": "testing",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/test-gen.md"
+      }
+    ],
+    "brainstorm": [
+      {
+        "name": "workflow:brainstorm:api-designer",
+        "description": "Generate or update api-designer/analysis.md addressing guidance-specification discussion points for API design perspective",
+        "arguments": "optional topic - uses existing framework if available",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "session-management",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/api-designer.md"
+      },
+      {
+        "name": "workflow:brainstorm:artifacts",
+        "description": "Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis",
+        "arguments": "topic or challenge description [--count N]",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "session-management",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/artifacts.md"
+      },
+      {
+        "name": "workflow:brainstorm:auto-parallel",
+        "description": "Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives",
+        "arguments": "topic or challenge description\" [--count N]",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "session-management",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/auto-parallel.md"
+      },
+      {
+        "name": "workflow:brainstorm:data-architect",
+        "description": "Generate or update data-architect/analysis.md addressing guidance-specification discussion points for data architecture perspective",
+        "arguments": "optional topic - uses existing framework if available",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "implementation",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/data-architect.md"
+      },
+      {
+        "name": "workflow:brainstorm:product-manager",
+        "description": "Generate or update product-manager/analysis.md addressing guidance-specification discussion points for product management perspective",
+        "arguments": "optional topic - uses existing framework if available",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "implementation",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/product-manager.md"
+      },
+      {
+        "name": "workflow:brainstorm:product-owner",
+        "description": "Generate or update product-owner/analysis.md addressing guidance-specification discussion points for product ownership perspective",
+        "arguments": "optional topic - uses existing framework if available",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "implementation",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/product-owner.md"
+      },
+      {
+        "name": "workflow:brainstorm:scrum-master",
+        "description": "Generate or update scrum-master/analysis.md addressing guidance-specification discussion points for Agile process perspective",
+        "arguments": "optional topic - uses existing framework if available",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "planning",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/scrum-master.md"
+      },
+      {
+        "name": "workflow:brainstorm:subject-matter-expert",
+        "description": "Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points for domain expertise perspective",
+        "arguments": "optional topic - uses existing framework if available",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "implementation",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/subject-matter-expert.md"
+      },
+      {
+        "name": "workflow:brainstorm:synthesis",
+        "description": "Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent",
+        "arguments": "[optional: --session session-id]",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "brainstorming",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/synthesis.md"
+      },
+      {
+        "name": "workflow:brainstorm:system-architect",
+        "description": "Generate or update system-architect/analysis.md addressing guidance-specification discussion points for system architecture perspective",
+        "arguments": "optional topic - uses existing framework if available",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "session-management",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/system-architect.md"
+      },
+      {
+        "name": "workflow:brainstorm:ui-designer",
+        "description": "Generate or update ui-designer/analysis.md addressing guidance-specification discussion points for UI design perspective",
+        "arguments": "optional topic - uses existing framework if available",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "planning",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/ui-designer.md"
+      },
+      {
+        "name": "workflow:brainstorm:ux-expert",
+        "description": "Generate or update ux-expert/analysis.md addressing guidance-specification discussion points for UX perspective",
+        "arguments": "optional topic - uses existing framework if available",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "implementation",
+        "difficulty": "Advanced",
+        "file_path": "workflow/brainstorm/ux-expert.md"
+      }
+    ],
+    "session": [
+      {
+        "name": "workflow:session:complete",
+        "description": "Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag",
+        "arguments": "# Complete current active session",
+        "category": "workflow",
+        "subcategory": "session",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/session/complete.md"
+      },
+      {
+        "name": "workflow:session:list",
+        "description": "List all workflow sessions with status filtering, shows session metadata and progress information",
+        "arguments": "# Show all sessions with status",
+        "category": "workflow",
+        "subcategory": "session",
+        "usage_scenario": "session-management",
+        "difficulty": "Basic",
+        "file_path": "workflow/session/list.md"
+      },
+      {
+        "name": "workflow:session:resume",
+        "description": "Resume the most recently paused workflow session with automatic session discovery and status update",
+        "arguments": "# Resume most recent paused session",
+        "category": "workflow",
+        "subcategory": "session",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/session/resume.md"
+      },
+      {
+        "name": "workflow:session:start",
+        "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
+        "arguments": "[--auto|--new] [optional: task description for new session]",
+        "category": "workflow",
+        "subcategory": "session",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "file_path": "workflow/session/start.md"
+      }
+    ],
+    "tools": [
+      {
+        "name": "workflow:tools:conflict-resolution",
+        "description": "Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen",
+        "arguments": "--session WFS-session-id --context path/to/context-package.json",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "brainstorming",
+        "difficulty": "Advanced",
+        "file_path": "workflow/tools/conflict-resolution.md"
+      },
+      {
+        "name": "workflow:tools:context-gather",
+        "description": "Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON",
+        "arguments": "--session WFS-session-id \\\"task description\\\"",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "implementation",
+        "difficulty": "Advanced",
+        "file_path": "workflow/tools/context-gather.md"
+      },
+      {
+        "name": "workflow:tools:task-generate-agent",
+        "description": "Autonomous task generation using action-planning-agent with discovery and output phases for workflow planning",
+        "arguments": "--session WFS-session-id [--cli-execute]",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "planning",
+        "difficulty": "Advanced",
+        "file_path": "workflow/tools/task-generate-agent.md"
+      },
+      {
+        "name": "workflow:tools:task-generate-tdd",
+        "description": "Generate TDD task chains with Red-Green-Refactor dependencies, test-first structure, and cycle validation",
+        "arguments": "--session WFS-session-id [--agent]",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "planning",
+        "difficulty": "Advanced",
+        "file_path": "workflow/tools/task-generate-tdd.md"
+      },
+      {
+        "name": "workflow:tools:task-generate",
+        "description": "",
+        "arguments": "--session WFS-auth",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "planning",
+        "difficulty": "Advanced",
+        "file_path": "workflow/tools/task-generate.md"
+      },
+      {
+        "name": "workflow:tools:tdd-coverage-analysis",
+        "description": "Analyze test coverage and TDD cycle execution with Red-Green-Refactor compliance verification",
+        "arguments": "--session WFS-session-id",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "testing",
+        "difficulty": "Advanced",
+        "file_path": "workflow/tools/tdd-coverage-analysis.md"
+      },
+      {
+        "name": "workflow:tools:test-concept-enhanced",
+        "description": "Analyze test requirements and generate test generation strategy using Gemini with test-context package",
+        "arguments": "--session WFS-test-session-id --context path/to/test-context-package.json",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "testing",
+        "difficulty": "Advanced",
+        "file_path": "workflow/tools/test-concept-enhanced.md"
+      },
+      {
+        "name": "workflow:tools:test-context-gather",
+        "description": "Collect test coverage context using test-context-search-agent and package into standardized test-context JSON",
+        "arguments": "--session WFS-test-session-id",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "implementation",
+        "difficulty": "Advanced",
+        "file_path": "workflow/tools/test-context-gather.md"
+      },
+      {
+        "name": "workflow:tools:test-task-generate",
+        "description": "Generate test-fix task JSON with iterative test-fix-retest cycle specification using Gemini/Qwen/Codex",
+        "arguments": "[--use-codex] [--cli-execute] --session WFS-test-session-id",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "session-management",
+        "difficulty": "Advanced",
+        "file_path": "workflow/tools/test-task-generate.md"
+      }
+    ],
+    "ui-design": [
+      {
+        "name": "workflow:ui-design:animation-extract",
+        "description": "Extract animation and transition patterns from URLs, CSS, or interactive questioning for design system documentation",
+        "arguments": "[--base-path <path>] [--session <id>] [--urls \"<list>\"] [--mode <auto|interactive>] [--focus \"<types>\"]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "documentation",
+        "difficulty": "Advanced",
+        "file_path": "workflow/ui-design/animation-extract.md"
+      },
+      {
+        "name": "workflow:ui-design:batch-generate",
+        "description": "Prompt-driven batch UI generation using target-style-centric parallel execution with design token application",
+        "arguments": "[--targets \"<list>\"] [--target-type \"page|component\"] [--device-type \"desktop|mobile|tablet|responsive\"] [--base-path <path>] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "ui-design",
+        "difficulty": "Advanced",
+        "file_path": "workflow/ui-design/batch-generate.md"
+      },
+      {
+        "name": "workflow:ui-design:capture",
+        "description": "Batch screenshot capture for UI design workflows using MCP puppeteer or local fallback with URL mapping",
+        "arguments": "--url-map \"target:url,...\" [--base-path path] [--session id]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "ui-design",
+        "difficulty": "Advanced",
+        "file_path": "workflow/ui-design/capture.md"
+      },
+      {
+        "name": "workflow:ui-design:explore-auto",
+        "description": "Exploratory UI design workflow with style-centric batch generation, creates design variants from prompts/images with parallel execution",
+        "arguments": "[--prompt \"<desc>\"] [--images \"<glob>\"] [--targets \"<list>\"] [--target-type \"page|component\"] [--session <id>] [--style-variants <count>] [--layout-variants <count>] [--batch-plan]\"",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "ui-design",
+        "difficulty": "Advanced",
+        "file_path": "workflow/ui-design/explore-auto.md"
+      },
+      {
+        "name": "workflow:ui-design:explore-layers",
+        "description": "Interactive deep UI capture with depth-controlled layer exploration using MCP puppeteer",
+        "arguments": "--url <url> --depth <1-5> [--session id] [--base-path path]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "ui-design",
+        "difficulty": "Advanced",
+        "file_path": "workflow/ui-design/explore-layers.md"
+      },
+      {
+        "name": "workflow:ui-design:generate",
+        "description": "Assemble UI prototypes by combining layout templates with design tokens, pure assembler without new content generation",
+        "arguments": "[--base-path <path>] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "ui-design",
+        "difficulty": "Advanced",
+        "file_path": "workflow/ui-design/generate.md"
+      },
+      {
+        "name": "workflow:ui-design:imitate-auto",
+        "description": "High-speed multi-page UI replication with batch screenshot capture and design token extraction",
+        "arguments": "--url-map \"<map>\" [--capture-mode <batch|deep>] [--depth <1-5>] [--session <id>] [--prompt \"<desc>\"]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "documentation",
+        "difficulty": "Advanced",
+        "file_path": "workflow/ui-design/imitate-auto.md"
+      },
+      {
+        "name": "workflow:ui-design:layout-extract",
+        "description": "Extract structural layout information from reference images, URLs, or text prompts using Claude analysis",
+        "arguments": "[--base-path <path>] [--session <id>] [--images \"<glob>\"] [--urls \"<list>\"] [--prompt \"<desc>\"] [--targets \"<list>\"] [--mode <imitate|explore>] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "ui-design",
+        "difficulty": "Advanced",
+        "file_path": "workflow/ui-design/layout-extract.md"
+      },
+      {
+        "name": "workflow:ui-design:style-extract",
+        "description": "Extract design style from reference images or text prompts using Claude analysis with variant generation",
+        "arguments": "[--base-path <path>] [--session <id>] [--images \"<glob>\"] [--urls \"<list>\"] [--prompt \"<desc>\"] [--mode <imitate|explore>] [--variants <count>]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "documentation",
+        "difficulty": "Advanced",
+        "file_path": "workflow/ui-design/style-extract.md"
+      },
+      {
+        "name": "workflow:ui-design:update",
+        "description": "Update brainstorming artifacts with finalized design system references from selected prototypes",
+        "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "ui-design",
+        "difficulty": "Advanced",
+        "file_path": "workflow/ui-design/update.md"
+      }
+    ]
+  }
+}

.claude/skills/command-guide/index/by-use-case.json

@@ -0,0 +1,712 @@
+{
+  "documentation": [
+    {
+      "name": "cli:analyze",
+      "description": "Read-only codebase analysis using Gemini (default), Qwen, or Codex with auto-pattern detection and template selection",
+      "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] analysis target",
+      "category": "cli",
+      "subcategory": "core",
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "file_path": "cli/analyze.md"
+    },
+    {
+      "name": "cli:chat",
+      "description": "Read-only Q&A interaction with Gemini/Qwen/Codex for codebase questions with automatic context inference",
+      "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] inquiry",
+      "category": "cli",
+      "subcategory": "core",
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "file_path": "cli/chat.md"
+    },
+    {
+      "name": "cli:cli-init",
+      "description": "Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection",
+      "arguments": "[--tool gemini|qwen|all] [--output path] [--preview]",
+      "category": "cli",
+      "subcategory": "core",
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "file_path": "cli/cli-init.md"
+    },
+    {
+      "name": "memory:load-skill-memory",
+      "description": "Activate SKILL package (auto-detect from paths/keywords or manual) and intelligently load documentation based on task intent keywords",
+      "arguments": "[skill_name] \\\"task intent description\\\"",
+      "category": "memory",
+      "subcategory": "core",
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "file_path": "memory/load-skill-memory.md"
+    },
+    {
+      "name": "memory:skill-memory",
+      "description": "4-phase autonomous orchestrator: check docs → /memory:docs planning → /workflow:execute → generate SKILL.md with progressive loading index (skips phases 2-3 if docs exist)",
+      "arguments": "[path] [--tool <gemini|qwen|codex>] [--regenerate] [--mode <full|partial>] [--cli-execute]",
+      "category": "memory",
+      "subcategory": "core",
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "file_path": "memory/skill-memory.md"
+    },
+    {
+      "name": "memory:tech-research",
+      "description": "3-phase orchestrator: extract tech stack from session/name → delegate to agent for Exa research and module generation → generate SKILL.md index (skips phase 2 if exists)",
+      "arguments": "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]",
+      "category": "memory",
+      "subcategory": "core",
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "file_path": "memory/tech-research.md"
+    },
+    {
+      "name": "memory:workflow-skill-memory",
+      "description": "Process WFS-* archived sessions using universal-executor agents with Gemini analysis to generate workflow-progress SKILL package (sessions-timeline, lessons, conflicts)",
+      "arguments": "session <session-id> | all",
+      "category": "memory",
+      "subcategory": "core",
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "file_path": "memory/workflow-skill-memory.md"
+    },
+    {
+      "name": "task:replan",
+      "description": "Update task JSON with new requirements or batch-update multiple tasks from verification report, tracks changes in task-changes.json",
+      "arguments": "task-id [\\\"text\\\"|file.md] | --batch [verification-report.md]",
+      "category": "task",
+      "subcategory": "core",
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "file_path": "task/replan.md"
+    },
+    {
+      "name": "workflow:ui-design:animation-extract",
+      "description": "Extract animation and transition patterns from URLs, CSS, or interactive questioning for design system documentation",
+      "arguments": "[--base-path <path>] [--session <id>] [--urls \"<list>\"] [--mode <auto|interactive>] [--focus \"<types>\"]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "documentation",
+      "difficulty": "Advanced",
+      "file_path": "workflow/ui-design/animation-extract.md"
+    },
+    {
+      "name": "workflow:ui-design:imitate-auto",
+      "description": "High-speed multi-page UI replication with batch screenshot capture and design token extraction",
+      "arguments": "--url-map \"<map>\" [--capture-mode <batch|deep>] [--depth <1-5>] [--session <id>] [--prompt \"<desc>\"]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "documentation",
+      "difficulty": "Advanced",
+      "file_path": "workflow/ui-design/imitate-auto.md"
+    },
+    {
+      "name": "workflow:ui-design:style-extract",
+      "description": "Extract design style from reference images or text prompts using Claude analysis with variant generation",
+      "arguments": "[--base-path <path>] [--session <id>] [--images \"<glob>\"] [--urls \"<list>\"] [--prompt \"<desc>\"] [--mode <imitate|explore>] [--variants <count>]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "documentation",
+      "difficulty": "Advanced",
+      "file_path": "workflow/ui-design/style-extract.md"
+    }
+  ],
+  "session-management": [
+    {
+      "name": "cli:codex-execute",
+      "description": "Multi-stage Codex execution with automatic task decomposition into grouped subtasks using resume mechanism for context continuity",
+      "arguments": "[--verify-git] task description or task-id",
+      "category": "cli",
+      "subcategory": "core",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "cli/codex-execute.md"
+    },
+    {
+      "name": "cli:discuss-plan",
+      "description": "Multi-round collaborative planning using Gemini, Codex, and Claude synthesis with iterative discussion cycles (read-only, no code changes)",
+      "arguments": "[--topic '...'] [--task-id '...'] [--rounds N]",
+      "category": "cli",
+      "subcategory": "core",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "cli/discuss-plan.md"
+    },
+    {
+      "name": "cli:execute",
+      "description": "Autonomous code implementation with YOLO auto-approval using Gemini/Qwen/Codex, supports task ID or description input with automatic file pattern detection",
+      "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] description or task-id",
+      "category": "cli",
+      "subcategory": "core",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "cli/execute.md"
+    },
+    {
+      "name": "enhance-prompt",
+      "description": "Enhanced prompt transformation using session memory and codebase analysis with --enhance flag detection",
+      "arguments": "user input to enhance",
+      "category": "general",
+      "subcategory": "core",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "enhance-prompt.md"
+    },
+    {
+      "name": "workflow:brainstorm:api-designer",
+      "description": "Generate or update api-designer/analysis.md addressing guidance-specification discussion points for API design perspective",
+      "arguments": "optional topic - uses existing framework if available",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "session-management",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/api-designer.md"
+    },
+    {
+      "name": "workflow:brainstorm:artifacts",
+      "description": "Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis",
+      "arguments": "topic or challenge description [--count N]",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "session-management",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/artifacts.md"
+    },
+    {
+      "name": "workflow:brainstorm:auto-parallel",
+      "description": "Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives",
+      "arguments": "topic or challenge description\" [--count N]",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "session-management",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/auto-parallel.md"
+    },
+    {
+      "name": "workflow:brainstorm:system-architect",
+      "description": "Generate or update system-architect/analysis.md addressing guidance-specification discussion points for system architecture perspective",
+      "arguments": "optional topic - uses existing framework if available",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "session-management",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/system-architect.md"
+    },
+    {
+      "name": "workflow:execute",
+      "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
+      "arguments": "[--resume-session=\\\"session-id\\\"]",
+      "category": "workflow",
+      "subcategory": "core",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/execute.md"
+    },
+    {
+      "name": "workflow:plan",
+      "description": "5-phase planning workflow with Gemini analysis and action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs with optional CLI auto-execution",
+      "arguments": "[--agent] [--cli-execute] \\\"text description\\\"|file.md",
+      "category": "workflow",
+      "subcategory": "core",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/plan.md"
+    },
+    {
+      "name": "workflow:session:complete",
+      "description": "Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag",
+      "arguments": "# Complete current active session",
+      "category": "workflow",
+      "subcategory": "session",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/session/complete.md"
+    },
+    {
+      "name": "workflow:session:list",
+      "description": "List all workflow sessions with status filtering, shows session metadata and progress information",
+      "arguments": "# Show all sessions with status",
+      "category": "workflow",
+      "subcategory": "session",
+      "usage_scenario": "session-management",
+      "difficulty": "Basic",
+      "file_path": "workflow/session/list.md"
+    },
+    {
+      "name": "workflow:session:resume",
+      "description": "Resume the most recently paused workflow session with automatic session discovery and status update",
+      "arguments": "# Resume most recent paused session",
+      "category": "workflow",
+      "subcategory": "session",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/session/resume.md"
+    },
+    {
+      "name": "workflow:session:start",
+      "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
+      "arguments": "[--auto|--new] [optional: task description for new session]",
+      "category": "workflow",
+      "subcategory": "session",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/session/start.md"
+    },
+    {
+      "name": "workflow:tdd-plan",
+      "description": "TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking",
+      "arguments": "[--agent] \\\"feature description\\\"|file.md",
+      "category": "workflow",
+      "subcategory": "core",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/tdd-plan.md"
+    },
+    {
+      "name": "workflow:tdd-verify",
+      "description": "Verify TDD workflow compliance against Red-Green-Refactor cycles, generate quality report with coverage analysis",
+      "arguments": "[optional: WFS-session-id]",
+      "category": "workflow",
+      "subcategory": "core",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/tdd-verify.md"
+    },
+    {
+      "name": "workflow:test-cycle-execute",
+      "description": "Execute test-fix workflow with dynamic task generation and iterative fix cycles until all tests pass or max iterations reached",
+      "arguments": "[--resume-session=\\\"session-id\\\"] [--max-iterations=N]",
+      "category": "workflow",
+      "subcategory": "core",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/test-cycle-execute.md"
+    },
+    {
+      "name": "workflow:tools:test-task-generate",
+      "description": "Generate test-fix task JSON with iterative test-fix-retest cycle specification using Gemini/Qwen/Codex",
+      "arguments": "[--use-codex] [--cli-execute] --session WFS-test-session-id",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "session-management",
+      "difficulty": "Advanced",
+      "file_path": "workflow/tools/test-task-generate.md"
+    }
+  ],
+  "analysis": [
+    {
+      "name": "cli:mode:bug-diagnosis",
+      "description": "Read-only bug root cause analysis using Gemini/Qwen/Codex with systematic diagnosis template for fix suggestions",
+      "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] bug description",
+      "category": "cli",
+      "subcategory": "mode",
+      "usage_scenario": "analysis",
+      "difficulty": "Intermediate",
+      "file_path": "cli/mode/bug-diagnosis.md"
+    }
+  ],
+  "implementation": [
+    {
+      "name": "cli:mode:code-analysis",
+      "description": "Read-only execution path tracing using Gemini/Qwen/Codex with specialized analysis template for call flow and optimization",
+      "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] analysis target",
+      "category": "cli",
+      "subcategory": "mode",
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "file_path": "cli/mode/code-analysis.md"
+    },
+    {
+      "name": "memory:load",
+      "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
+      "arguments": "[--tool gemini|qwen] \\\"task context description\\\"",
+      "category": "memory",
+      "subcategory": "core",
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "file_path": "memory/load.md"
+    },
+    {
+      "name": "memory:update-full",
+      "description": "Update all CLAUDE.md files using layer-based execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
+      "arguments": "[--tool gemini|qwen|codex] [--path <directory>]",
+      "category": "memory",
+      "subcategory": "core",
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "file_path": "memory/update-full.md"
+    },
+    {
+      "name": "memory:update-related",
+      "description": "Update CLAUDE.md for git-changed modules using batched agent execution (4 modules/agent) with gemini→qwen→codex fallback, <15 modules uses direct execution",
+      "arguments": "[--tool gemini|qwen|codex]",
+      "category": "memory",
+      "subcategory": "core",
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "file_path": "memory/update-related.md"
+    },
+    {
+      "name": "task:execute",
+      "description": "Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking",
+      "arguments": "task-id",
+      "category": "task",
+      "subcategory": "core",
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "file_path": "task/execute.md"
+    },
+    {
+      "name": "workflow:brainstorm:data-architect",
+      "description": "Generate or update data-architect/analysis.md addressing guidance-specification discussion points for data architecture perspective",
+      "arguments": "optional topic - uses existing framework if available",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "implementation",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/data-architect.md"
+    },
+    {
+      "name": "workflow:brainstorm:product-manager",
+      "description": "Generate or update product-manager/analysis.md addressing guidance-specification discussion points for product management perspective",
+      "arguments": "optional topic - uses existing framework if available",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "implementation",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/product-manager.md"
+    },
+    {
+      "name": "workflow:brainstorm:product-owner",
+      "description": "Generate or update product-owner/analysis.md addressing guidance-specification discussion points for product ownership perspective",
+      "arguments": "optional topic - uses existing framework if available",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "implementation",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/product-owner.md"
+    },
+    {
+      "name": "workflow:brainstorm:subject-matter-expert",
+      "description": "Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points for domain expertise perspective",
+      "arguments": "optional topic - uses existing framework if available",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "implementation",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/subject-matter-expert.md"
+    },
+    {
+      "name": "workflow:brainstorm:ux-expert",
+      "description": "Generate or update ux-expert/analysis.md addressing guidance-specification discussion points for UX perspective",
+      "arguments": "optional topic - uses existing framework if available",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "implementation",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/ux-expert.md"
+    },
+    {
+      "name": "workflow:resume",
+      "description": "Resume paused workflow session with automatic progress analysis, pending task identification, and conflict detection",
+      "arguments": "session-id for workflow session to resume",
+      "category": "workflow",
+      "subcategory": "core",
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/resume.md"
+    },
+    {
+      "name": "workflow:tools:context-gather",
+      "description": "Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON",
+      "arguments": "--session WFS-session-id \\\"task description\\\"",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "implementation",
+      "difficulty": "Advanced",
+      "file_path": "workflow/tools/context-gather.md"
+    },
+    {
+      "name": "workflow:tools:test-context-gather",
+      "description": "Collect test coverage context using test-context-search-agent and package into standardized test-context JSON",
+      "arguments": "--session WFS-test-session-id",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "implementation",
+      "difficulty": "Advanced",
+      "file_path": "workflow/tools/test-context-gather.md"
+    }
+  ],
+  "planning": [
+    {
+      "name": "cli:mode:plan",
+      "description": "Read-only architecture planning using Gemini/Qwen/Codex with strategic planning template for modification plans and impact analysis",
+      "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] topic",
+      "category": "cli",
+      "subcategory": "mode",
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "file_path": "cli/mode/plan.md"
+    },
+    {
+      "name": "memory:docs",
+      "description": "Plan documentation workflow with dynamic grouping (≤10 docs/task), generates IMPL tasks for parallel module trees, README, ARCHITECTURE, and HTTP API docs",
+      "arguments": "[path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]",
+      "category": "memory",
+      "subcategory": "core",
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "file_path": "memory/docs.md"
+    },
+    {
+      "name": "task:breakdown",
+      "description": "Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order",
+      "arguments": "task-id",
+      "category": "task",
+      "subcategory": "core",
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "file_path": "task/breakdown.md"
+    },
+    {
+      "name": "workflow:action-plan-verify",
+      "description": "Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation",
+      "arguments": "[optional: --session session-id]",
+      "category": "workflow",
+      "subcategory": "core",
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/action-plan-verify.md"
+    },
+    {
+      "name": "workflow:brainstorm:scrum-master",
+      "description": "Generate or update scrum-master/analysis.md addressing guidance-specification discussion points for Agile process perspective",
+      "arguments": "optional topic - uses existing framework if available",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "planning",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/scrum-master.md"
+    },
+    {
+      "name": "workflow:brainstorm:ui-designer",
+      "description": "Generate or update ui-designer/analysis.md addressing guidance-specification discussion points for UI design perspective",
+      "arguments": "optional topic - uses existing framework if available",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "planning",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/ui-designer.md"
+    },
+    {
+      "name": "workflow:tools:task-generate-agent",
+      "description": "Autonomous task generation using action-planning-agent with discovery and output phases for workflow planning",
+      "arguments": "--session WFS-session-id [--cli-execute]",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "planning",
+      "difficulty": "Advanced",
+      "file_path": "workflow/tools/task-generate-agent.md"
+    },
+    {
+      "name": "workflow:tools:task-generate-tdd",
+      "description": "Generate TDD task chains with Red-Green-Refactor dependencies, test-first structure, and cycle validation",
+      "arguments": "--session WFS-session-id [--agent]",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "planning",
+      "difficulty": "Advanced",
+      "file_path": "workflow/tools/task-generate-tdd.md"
+    },
+    {
+      "name": "workflow:tools:task-generate",
+      "description": "",
+      "arguments": "--session WFS-auth",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "planning",
+      "difficulty": "Advanced",
+      "file_path": "workflow/tools/task-generate.md"
+    }
+  ],
+  "testing": [
+    {
+      "name": "task:create",
+      "description": "Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis",
+      "arguments": "\\\"task title\\\"",
+      "category": "task",
+      "subcategory": "core",
+      "usage_scenario": "testing",
+      "difficulty": "Intermediate",
+      "file_path": "task/create.md"
+    },
+    {
+      "name": "workflow:review",
+      "description": "Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini",
+      "arguments": "[--type=security|architecture|action-items|quality] [optional: session-id]",
+      "category": "workflow",
+      "subcategory": "core",
+      "usage_scenario": "testing",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/review.md"
+    },
+    {
+      "name": "workflow:test-fix-gen",
+      "description": "Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning",
+      "arguments": "[--use-codex] [--cli-execute] (source-session-id | \\\"feature description\\\" | /path/to/file.md)",
+      "category": "workflow",
+      "subcategory": "core",
+      "usage_scenario": "testing",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/test-fix-gen.md"
+    },
+    {
+      "name": "workflow:test-gen",
+      "description": "Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks",
+      "arguments": "[--use-codex] [--cli-execute] source-session-id",
+      "category": "workflow",
+      "subcategory": "core",
+      "usage_scenario": "testing",
+      "difficulty": "Intermediate",
+      "file_path": "workflow/test-gen.md"
+    },
+    {
+      "name": "workflow:tools:tdd-coverage-analysis",
+      "description": "Analyze test coverage and TDD cycle execution with Red-Green-Refactor compliance verification",
+      "arguments": "--session WFS-session-id",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "testing",
+      "difficulty": "Advanced",
+      "file_path": "workflow/tools/tdd-coverage-analysis.md"
+    },
+    {
+      "name": "workflow:tools:test-concept-enhanced",
+      "description": "Analyze test requirements and generate test generation strategy using Gemini with test-context package",
+      "arguments": "--session WFS-test-session-id --context path/to/test-context-package.json",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "testing",
+      "difficulty": "Advanced",
+      "file_path": "workflow/tools/test-concept-enhanced.md"
+    }
+  ],
+  "utilities": [
+    {
+      "name": "version",
+      "description": "Display Claude Code version information and check for updates",
+      "arguments": "",
+      "category": "general",
+      "subcategory": "core",
+      "usage_scenario": "utilities",
+      "difficulty": "Basic",
+      "file_path": "version.md"
+    }
+  ],
+  "brainstorming": [
+    {
+      "name": "workflow:brainstorm:synthesis",
+      "description": "Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent",
+      "arguments": "[optional: --session session-id]",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "brainstorming",
+      "difficulty": "Advanced",
+      "file_path": "workflow/brainstorm/synthesis.md"
+    },
+    {
+      "name": "workflow:tools:conflict-resolution",
+      "description": "Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen",
+      "arguments": "--session WFS-session-id --context path/to/context-package.json",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "brainstorming",
+      "difficulty": "Advanced",
+      "file_path": "workflow/tools/conflict-resolution.md"
+    }
+  ],
+  "monitoring": [
+    {
+      "name": "workflow:status",
+      "description": "Generate on-demand task status views from JSON task data with optional task-id filtering for detailed view",
+      "arguments": "[optional: task-id]",
+      "category": "workflow",
+      "subcategory": "core",
+      "usage_scenario": "monitoring",
+      "difficulty": "Basic",
+      "file_path": "workflow/status.md"
+    }
+  ],
+  "ui-design": [
+    {
+      "name": "workflow:ui-design:batch-generate",
+      "description": "Prompt-driven batch UI generation using target-style-centric parallel execution with design token application",
+      "arguments": "[--targets \"<list>\"] [--target-type \"page|component\"] [--device-type \"desktop|mobile|tablet|responsive\"] [--base-path <path>] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "ui-design",
+      "difficulty": "Advanced",
+      "file_path": "workflow/ui-design/batch-generate.md"
+    },
+    {
+      "name": "workflow:ui-design:capture",
+      "description": "Batch screenshot capture for UI design workflows using MCP puppeteer or local fallback with URL mapping",
+      "arguments": "--url-map \"target:url,...\" [--base-path path] [--session id]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "ui-design",
+      "difficulty": "Advanced",
+      "file_path": "workflow/ui-design/capture.md"
+    },
+    {
+      "name": "workflow:ui-design:explore-auto",
+      "description": "Exploratory UI design workflow with style-centric batch generation, creates design variants from prompts/images with parallel execution",
+      "arguments": "[--prompt \"<desc>\"] [--images \"<glob>\"] [--targets \"<list>\"] [--target-type \"page|component\"] [--session <id>] [--style-variants <count>] [--layout-variants <count>] [--batch-plan]\"",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "ui-design",
+      "difficulty": "Advanced",
+      "file_path": "workflow/ui-design/explore-auto.md"
+    },
+    {
+      "name": "workflow:ui-design:explore-layers",
+      "description": "Interactive deep UI capture with depth-controlled layer exploration using MCP puppeteer",
+      "arguments": "--url <url> --depth <1-5> [--session id] [--base-path path]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "ui-design",
+      "difficulty": "Advanced",
+      "file_path": "workflow/ui-design/explore-layers.md"
+    },
+    {
+      "name": "workflow:ui-design:generate",
+      "description": "Assemble UI prototypes by combining layout templates with design tokens, pure assembler without new content generation",
+      "arguments": "[--base-path <path>] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "ui-design",
+      "difficulty": "Advanced",
+      "file_path": "workflow/ui-design/generate.md"
+    },
+    {
+      "name": "workflow:ui-design:layout-extract",
+      "description": "Extract structural layout information from reference images, URLs, or text prompts using Claude analysis",
+      "arguments": "[--base-path <path>] [--session <id>] [--images \"<glob>\"] [--urls \"<list>\"] [--prompt \"<desc>\"] [--targets \"<list>\"] [--mode <imitate|explore>] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "ui-design",
+      "difficulty": "Advanced",
+      "file_path": "workflow/ui-design/layout-extract.md"
+    },
+    {
+      "name": "workflow:ui-design:update",
+      "description": "Update brainstorming artifacts with finalized design system references from selected prototypes",
+      "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "ui-design",
+      "difficulty": "Advanced",
+      "file_path": "workflow/ui-design/update.md"
+    }
+  ]
+}

.claude/skills/command-guide/index/command-relationships.json

@@ -0,0 +1,616 @@
+{
+  "cli:analyze": {
+    "related_commands": [
+      "cli:chat",
+      "cli:mode:code-analysis"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "cli:chat": {
+    "related_commands": [
+      "cli:analyze",
+      "memory:load"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "cli:cli-init": {
+    "related_commands": [],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "cli:codex-execute": {
+    "related_commands": [
+      "cli:execute",
+      "task:execute"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "cli:discuss-plan": {
+    "related_commands": [],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "cli:execute": {
+    "related_commands": [
+      "cli:codex-execute",
+      "task:execute"
+    ],
+    "next_steps": [
+      "workflow:status"
+    ],
+    "prerequisites": []
+  },
+  "cli:mode:bug-diagnosis": {
+    "related_commands": [
+      "cli:mode:code-analysis",
+      "cli:execute"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "cli:mode:code-analysis": {
+    "related_commands": [
+      "cli:analyze",
+      "cli:mode:bug-diagnosis"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "cli:mode:plan": {
+    "related_commands": [
+      "workflow:plan",
+      "cli:analyze"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "enhance-prompt": {
+    "related_commands": [
+      "workflow:plan",
+      "cli:execute"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "memory:docs": {
+    "related_commands": [
+      "memory:update-full",
+      "memory:update-related"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "memory:load-skill-memory": {
+    "related_commands": [
+      "memory:load"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "memory:skill-memory"
+    ]
+  },
+  "memory:load": {
+    "related_commands": [
+      "memory:skill-memory",
+      "memory:load-skill-memory"
+    ],
+    "next_steps": [
+      "workflow:plan",
+      "cli:execute"
+    ],
+    "prerequisites": []
+  },
+  "memory:skill-memory": {
+    "related_commands": [
+      "memory:docs",
+      "memory:update-full"
+    ],
+    "next_steps": [
+      "memory:load-skill-memory"
+    ],
+    "prerequisites": []
+  },
+  "memory:tech-research": {
+    "related_commands": [],
+    "next_steps": [
+      "memory:load-skill-memory"
+    ],
+    "prerequisites": []
+  },
+  "memory:update-full": {
+    "related_commands": [
+      "memory:update-related"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "memory:docs"
+    ]
+  },
+  "memory:update-related": {
+    "related_commands": [
+      "memory:update-full",
+      "memory:docs"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "memory:workflow-skill-memory": {
+    "related_commands": [
+      "memory:skill-memory",
+      "workflow:session:list"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "task:breakdown": {
+    "related_commands": [],
+    "next_steps": [
+      "task:execute"
+    ],
+    "prerequisites": [
+      "task:create"
+    ]
+  },
+  "task:create": {
+    "related_commands": [
+      "task:breakdown",
+      "workflow:plan"
+    ],
+    "next_steps": [
+      "task:execute"
+    ],
+    "prerequisites": []
+  },
+  "task:execute": {
+    "related_commands": [
+      "workflow:execute",
+      "workflow:status",
+      "task:create"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "task:replan": {
+    "related_commands": [
+      "task:execute",
+      "workflow:action-plan-verify"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "version": {
+    "related_commands": [],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:action-plan-verify": {
+    "related_commands": [
+      "workflow:status"
+    ],
+    "next_steps": [
+      "workflow:execute"
+    ],
+    "prerequisites": [
+      "workflow:plan"
+    ]
+  },
+  "workflow:brainstorm:api-designer": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:brainstorm:artifacts": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan"
+    ],
+    "next_steps": [
+      "workflow:plan"
+    ],
+    "prerequisites": []
+  },
+  "workflow:brainstorm:auto-parallel": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan"
+    ],
+    "next_steps": [
+      "workflow:brainstorm:synthesis"
+    ],
+    "prerequisites": []
+  },
+  "workflow:brainstorm:data-architect": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:brainstorm:product-manager": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:brainstorm:product-owner": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:brainstorm:scrum-master": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:brainstorm:subject-matter-expert": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:brainstorm:synthesis": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan",
+      "workflow:brainstorm:artifacts"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:brainstorm:system-architect": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:brainstorm:ui-designer": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:brainstorm:ux-expert": {
+    "related_commands": [
+      "workflow:brainstorm:synthesis",
+      "workflow:plan"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:execute": {
+    "related_commands": [
+      "workflow:status",
+      "task:execute",
+      "workflow:session:start"
+    ],
+    "next_steps": [
+      "workflow:review",
+      "workflow:test-cycle-execute"
+    ],
+    "prerequisites": [
+      "workflow:plan"
+    ]
+  },
+  "workflow:plan": {
+    "related_commands": [
+      "workflow:status",
+      "workflow:tdd-plan",
+      "workflow:session:start"
+    ],
+    "next_steps": [
+      "workflow:action-plan-verify",
+      "workflow:execute"
+    ],
+    "prerequisites": []
+  },
+  "workflow:resume": {
+    "related_commands": [
+      "workflow:session:start",
+      "workflow:status",
+      "workflow:execute"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:review": {
+    "related_commands": [
+      "workflow:status"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "workflow:execute"
+    ]
+  },
+  "workflow:session:complete": {
+    "related_commands": [
+      "workflow:review",
+      "workflow:session:list"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "workflow:execute"
+    ]
+  },
+  "workflow:session:list": {
+    "related_commands": [
+      "workflow:session:start",
+      "workflow:session:resume"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:session:resume": {
+    "related_commands": [
+      "workflow:resume",
+      "workflow:status"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "workflow:session:start"
+    ]
+  },
+  "workflow:session:start": {
+    "related_commands": [
+      "workflow:session:list",
+      "workflow:session:resume"
+    ],
+    "next_steps": [
+      "workflow:plan",
+      "workflow:execute"
+    ],
+    "prerequisites": []
+  },
+  "workflow:status": {
+    "related_commands": [
+      "workflow:execute",
+      "workflow:plan",
+      "task:execute"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:tdd-plan": {
+    "related_commands": [
+      "workflow:plan",
+      "workflow:test-cycle-execute"
+    ],
+    "next_steps": [
+      "workflow:execute",
+      "workflow:tdd-verify"
+    ],
+    "prerequisites": []
+  },
+  "workflow:tdd-verify": {
+    "related_commands": [
+      "workflow:test-cycle-execute",
+      "workflow:review"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "workflow:tdd-plan"
+    ]
+  },
+  "workflow:test-cycle-execute": {
+    "related_commands": [
+      "workflow:tdd-verify",
+      "workflow:execute"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "workflow:test-gen",
+      "workflow:test-fix-gen"
+    ]
+  },
+  "workflow:test-fix-gen": {
+    "related_commands": [],
+    "next_steps": [
+      "workflow:test-cycle-execute"
+    ],
+    "prerequisites": []
+  },
+  "workflow:test-gen": {
+    "related_commands": [],
+    "next_steps": [
+      "workflow:test-cycle-execute"
+    ],
+    "prerequisites": [
+      "workflow:execute"
+    ]
+  },
+  "workflow:tools:conflict-resolution": {
+    "related_commands": [],
+    "next_steps": [
+      "workflow:tools:task-generate"
+    ],
+    "prerequisites": [
+      "workflow:tools:context-gather"
+    ]
+  },
+  "workflow:tools:context-gather": {
+    "related_commands": [
+      "memory:load",
+      "workflow:tools:conflict-resolution"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "workflow:plan"
+    ]
+  },
+  "workflow:tools:task-generate-agent": {
+    "related_commands": [
+      "workflow:tools:task-generate"
+    ],
+    "next_steps": [
+      "workflow:execute"
+    ],
+    "prerequisites": [
+      "workflow:plan"
+    ]
+  },
+  "workflow:tools:task-generate-tdd": {
+    "related_commands": [
+      "workflow:tools:task-generate"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "workflow:tdd-plan"
+    ]
+  },
+  "workflow:tools:task-generate": {
+    "related_commands": [],
+    "next_steps": [
+      "workflow:execute"
+    ],
+    "prerequisites": [
+      "workflow:plan"
+    ]
+  },
+  "workflow:tools:tdd-coverage-analysis": {
+    "related_commands": [
+      "workflow:tdd-verify"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "workflow:tdd-plan"
+    ]
+  },
+  "workflow:tools:test-concept-enhanced": {
+    "related_commands": [],
+    "next_steps": [],
+    "prerequisites": [
+      "workflow:tools:test-context-gather"
+    ]
+  },
+  "workflow:tools:test-context-gather": {
+    "related_commands": [
+      "workflow:tools:context-gather"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "workflow:test-gen"
+    ]
+  },
+  "workflow:tools:test-task-generate": {
+    "related_commands": [
+      "workflow:tools:task-generate"
+    ],
+    "next_steps": [],
+    "prerequisites": [
+      "workflow:test-gen"
+    ]
+  },
+  "workflow:ui-design:animation-extract": {
+    "related_commands": [
+      "workflow:plan",
+      "workflow:brainstorm:ui-designer"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:ui-design:batch-generate": {
+    "related_commands": [
+      "workflow:plan",
+      "workflow:brainstorm:ui-designer"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:ui-design:capture": {
+    "related_commands": [
+      "workflow:plan",
+      "workflow:brainstorm:ui-designer"
+    ],
+    "next_steps": [
+      "workflow:ui-design:layout-extract",
+      "workflow:ui-design:style-extract"
+    ],
+    "prerequisites": []
+  },
+  "workflow:ui-design:explore-auto": {
+    "related_commands": [
+      "workflow:plan",
+      "workflow:brainstorm:ui-designer"
+    ],
+    "next_steps": [
+      "workflow:ui-design:generate",
+      "workflow:ui-design:update"
+    ],
+    "prerequisites": []
+  },
+  "workflow:ui-design:explore-layers": {
+    "related_commands": [
+      "workflow:plan",
+      "workflow:brainstorm:ui-designer"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:ui-design:generate": {
+    "related_commands": [
+      "workflow:plan",
+      "workflow:brainstorm:ui-designer"
+    ],
+    "next_steps": [
+      "workflow:ui-design:update",
+      "workflow:plan"
+    ],
+    "prerequisites": []
+  },
+  "workflow:ui-design:imitate-auto": {
+    "related_commands": [
+      "workflow:plan",
+      "workflow:brainstorm:ui-designer"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  },
+  "workflow:ui-design:layout-extract": {
+    "related_commands": [
+      "workflow:plan",
+      "workflow:brainstorm:ui-designer"
+    ],
+    "next_steps": [
+      "workflow:ui-design:generate"
+    ],
+    "prerequisites": []
+  },
+  "workflow:ui-design:style-extract": {
+    "related_commands": [
+      "workflow:plan",
+      "workflow:brainstorm:ui-designer"
+    ],
+    "next_steps": [
+      "workflow:ui-design:generate"
+    ],
+    "prerequisites": []
+  },
+  "workflow:ui-design:update": {
+    "related_commands": [
+      "workflow:plan",
+      "workflow:brainstorm:ui-designer"
+    ],
+    "next_steps": [],
+    "prerequisites": []
+  }
+}

.claude/skills/command-guide/index/essential-commands.json

@@ -0,0 +1,142 @@
+[
+  {
+    "name": "cli:codex-execute",
+    "description": "Multi-stage Codex execution with automatic task decomposition into grouped subtasks using resume mechanism for context continuity",
+    "arguments": "[--verify-git] task description or task-id",
+    "category": "cli",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "cli/codex-execute.md"
+  },
+  {
+    "name": "cli:execute",
+    "description": "Autonomous code implementation with YOLO auto-approval using Gemini/Qwen/Codex, supports task ID or description input with automatic file pattern detection",
+    "arguments": "[--agent] [--tool codex|gemini|qwen] [--enhance] description or task-id",
+    "category": "cli",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "cli/execute.md"
+  },
+  {
+    "name": "memory:load",
+    "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
+    "arguments": "[--tool gemini|qwen] \\\"task context description\\\"",
+    "category": "memory",
+    "subcategory": "core",
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "file_path": "memory/load.md"
+  },
+  {
+    "name": "memory:skill-memory",
+    "description": "4-phase autonomous orchestrator: check docs → /memory:docs planning → /workflow:execute → generate SKILL.md with progressive loading index (skips phases 2-3 if docs exist)",
+    "arguments": "[path] [--tool <gemini|qwen|codex>] [--regenerate] [--mode <full|partial>] [--cli-execute]",
+    "category": "memory",
+    "subcategory": "core",
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "file_path": "memory/skill-memory.md"
+  },
+  {
+    "name": "task:create",
+    "description": "Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis",
+    "arguments": "\\\"task title\\\"",
+    "category": "task",
+    "subcategory": "core",
+    "usage_scenario": "testing",
+    "difficulty": "Intermediate",
+    "file_path": "task/create.md"
+  },
+  {
+    "name": "task:execute",
+    "description": "Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking",
+    "arguments": "task-id",
+    "category": "task",
+    "subcategory": "core",
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "file_path": "task/execute.md"
+  },
+  {
+    "name": "version",
+    "description": "Display Claude Code version information and check for updates",
+    "arguments": "",
+    "category": "general",
+    "subcategory": "core",
+    "usage_scenario": "utilities",
+    "difficulty": "Basic",
+    "file_path": "version.md"
+  },
+  {
+    "name": "workflow:action-plan-verify",
+    "description": "Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation",
+    "arguments": "[optional: --session session-id]",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/action-plan-verify.md"
+  },
+  {
+    "name": "workflow:execute",
+    "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
+    "arguments": "[--resume-session=\\\"session-id\\\"]",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/execute.md"
+  },
+  {
+    "name": "workflow:plan",
+    "description": "5-phase planning workflow with Gemini analysis and action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs with optional CLI auto-execution",
+    "arguments": "[--agent] [--cli-execute] \\\"text description\\\"|file.md",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/plan.md"
+  },
+  {
+    "name": "workflow:resume",
+    "description": "Resume paused workflow session with automatic progress analysis, pending task identification, and conflict detection",
+    "arguments": "session-id for workflow session to resume",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/resume.md"
+  },
+  {
+    "name": "workflow:session:start",
+    "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
+    "arguments": "[--auto|--new] [optional: task description for new session]",
+    "category": "workflow",
+    "subcategory": "session",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/session/start.md"
+  },
+  {
+    "name": "workflow:status",
+    "description": "Generate on-demand task status views from JSON task data with optional task-id filtering for detailed view",
+    "arguments": "[optional: task-id]",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "monitoring",
+    "difficulty": "Basic",
+    "file_path": "workflow/status.md"
+  },
+  {
+    "name": "workflow:test-cycle-execute",
+    "description": "Execute test-fix workflow with dynamic task generation and iterative fix cycles until all tests pass or max iterations reached",
+    "arguments": "[--resume-session=\\\"session-id\\\"] [--max-iterations=N]",
+    "category": "workflow",
+    "subcategory": "core",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "file_path": "workflow/test-cycle-execute.md"
+  }
+]

.claude/skills/command-guide/scripts/analyze_commands.py

@@ -0,0 +1,411 @@
+#!/usr/bin/env python3
+"""
+Analyze all command files and generate index files for command-guide skill.
+"""
+
+import os
+import re
+import json
+from pathlib import Path
+from collections import defaultdict
+from typing import Dict, List, Any
+
+# Base paths
+COMMANDS_DIR = Path("D:/Claude_dms3/.claude/commands")
+INDEX_DIR = Path("D:/Claude_dms3/.claude/skills/command-guide/index")
+
+def parse_frontmatter(content: str) -> Dict[str, Any]:
+    """Extract YAML frontmatter from markdown content."""
+    frontmatter = {}
+    if content.startswith('---'):
+        lines = content.split('\n')
+        in_frontmatter = False
+        for i, line in enumerate(lines[1:], 1):
+            if line.strip() == '---':
+                break
+            if ':' in line:
+                key, value = line.split(':', 1)
+                frontmatter[key.strip()] = value.strip().strip('"')
+    return frontmatter
+
+def categorize_command(file_path: Path) -> tuple:
+    """Determine category and subcategory from file path."""
+    parts = file_path.relative_to(COMMANDS_DIR).parts
+
+    if len(parts) == 1:
+        return "general", None
+
+    category = parts[0]  # cli, memory, task, workflow
+    subcategory = parts[1].replace('.md', '') if len(parts) > 2 else None
+
+    return category, subcategory
+
+def determine_usage_scenario(name: str, description: str, category: str) -> str:
+    """Determine primary usage scenario for command."""
+    name_lower = name.lower()
+    desc_lower = description.lower()
+
+    # Planning indicators
+    if any(word in name_lower for word in ['plan', 'design', 'breakdown', 'brainstorm']):
+        return "planning"
+
+    # Implementation indicators
+    if any(word in name_lower for word in ['implement', 'execute', 'generate', 'create', 'write']):
+        return "implementation"
+
+    # Testing indicators
+    if any(word in name_lower for word in ['test', 'tdd', 'verify', 'coverage']):
+        return "testing"
+
+    # Documentation indicators
+    if any(word in name_lower for word in ['docs', 'documentation', 'memory']):
+        return "documentation"
+
+    # Session management indicators
+    if any(word in name_lower for word in ['session', 'resume', 'status', 'complete']):
+        return "session-management"
+
+    # Analysis indicators
+    if any(word in name_lower for word in ['analyze', 'review', 'diagnosis']):
+        return "analysis"
+
+    return "general"
+
+def determine_difficulty(name: str, description: str, category: str) -> str:
+    """Determine difficulty level."""
+    name_lower = name.lower()
+
+    # Beginner commands
+    beginner_keywords = ['status', 'list', 'chat', 'analyze', 'version']
+    if any(word in name_lower for word in beginner_keywords):
+        return "Beginner"
+
+    # Advanced commands
+    advanced_keywords = ['tdd', 'conflict', 'agent', 'auto-parallel', 'coverage', 'synthesis']
+    if any(word in name_lower for word in advanced_keywords):
+        return "Advanced"
+
+    # Intermediate by default
+    return "Intermediate"
+
+def analyze_command_file(file_path: Path) -> Dict[str, Any]:
+    """Analyze a single command file and extract metadata."""
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    # Parse frontmatter
+    frontmatter = parse_frontmatter(content)
+
+    # Extract data
+    name = frontmatter.get('name', file_path.stem)
+    description = frontmatter.get('description', '')
+    argument_hint = frontmatter.get('argument-hint', '')
+
+    # Determine categorization
+    category, subcategory = categorize_command(file_path)
+    usage_scenario = determine_usage_scenario(name, description, category)
+    difficulty = determine_difficulty(name, description, category)
+
+    # Build relative path
+    rel_path = str(file_path.relative_to(COMMANDS_DIR)).replace('\\', '/')
+
+    # Build full command name from frontmatter name or construct it
+    # If name already contains colons (e.g., "workflow:status"), use it directly
+    if ':' in name:
+        command_name = f"/{name}"
+    elif category == "general":
+        command_name = f"/{name}"
+    else:
+        # For subcategorized commands, build the full path
+        if subcategory:
+            command_name = f"/{category}:{subcategory}:{name}"
+        else:
+            command_name = f"/{category}:{name}"
+
+    return {
+        "name": name,
+        "command": command_name,
+        "description": description,
+        "arguments": argument_hint,
+        "category": category,
+        "subcategory": subcategory,
+        "usage_scenario": usage_scenario,
+        "difficulty": difficulty,
+        "file_path": rel_path
+    }
+
+def build_command_relationships() -> Dict[str, Any]:
+    """Build command relationship mappings."""
+    relationships = {
+        # Workflow planning commands
+        "workflow:plan": {
+            "calls_internally": [
+                "workflow:session:start",
+                "workflow:tools:context-gather",
+                "workflow:tools:conflict-resolution",
+                "workflow:tools:task-generate",
+                "workflow:tools:task-generate-agent"
+            ],
+            "next_steps": ["workflow:action-plan-verify", "workflow:status", "workflow:execute"],
+            "alternatives": ["workflow:tdd-plan"],
+            "prerequisites": []
+        },
+        "workflow:tdd-plan": {
+            "calls_internally": [
+                "workflow:session:start",
+                "workflow:tools:context-gather",
+                "workflow:tools:task-generate-tdd"
+            ],
+            "next_steps": ["workflow:tdd-verify", "workflow:status", "workflow:execute"],
+            "alternatives": ["workflow:plan"],
+            "prerequisites": []
+        },
+
+        # Execution commands
+        "workflow:execute": {
+            "prerequisites": ["workflow:plan", "workflow:tdd-plan"],
+            "related": ["workflow:status", "workflow:resume"],
+            "next_steps": ["workflow:review", "workflow:tdd-verify"]
+        },
+
+        # Verification commands
+        "workflow:action-plan-verify": {
+            "prerequisites": ["workflow:plan"],
+            "next_steps": ["workflow:execute"],
+            "related": ["workflow:status"]
+        },
+        "workflow:tdd-verify": {
+            "prerequisites": ["workflow:execute"],
+            "related": ["workflow:tools:tdd-coverage-analysis"]
+        },
+
+        # Session management
+        "workflow:session:start": {
+            "next_steps": ["workflow:plan", "workflow:execute"],
+            "related": ["workflow:session:list", "workflow:session:resume"]
+        },
+        "workflow:session:resume": {
+            "alternatives": ["workflow:resume"],
+            "related": ["workflow:session:list", "workflow:status"]
+        },
+        "workflow:resume": {
+            "alternatives": ["workflow:session:resume"],
+            "related": ["workflow:status"]
+        },
+
+        # Task management
+        "task:create": {
+            "next_steps": ["task:execute"],
+            "related": ["task:breakdown"]
+        },
+        "task:breakdown": {
+            "next_steps": ["task:execute"],
+            "related": ["task:create"]
+        },
+        "task:replan": {
+            "prerequisites": ["workflow:plan"],
+            "related": ["workflow:action-plan-verify"]
+        },
+        "task:execute": {
+            "prerequisites": ["task:create", "task:breakdown", "workflow:plan"],
+            "related": ["workflow:status"]
+        },
+
+        # Memory/Documentation
+        "memory:docs": {
+            "calls_internally": [
+                "workflow:session:start",
+                "workflow:tools:context-gather"
+            ],
+            "next_steps": ["workflow:execute"]
+        },
+        "memory:skill-memory": {
+            "next_steps": ["workflow:plan", "cli:analyze"],
+            "related": ["memory:load-skill-memory"]
+        },
+        "memory:workflow-skill-memory": {
+            "related": ["memory:skill-memory"],
+            "next_steps": ["workflow:plan"]
+        },
+
+        # CLI modes
+        "cli:execute": {
+            "alternatives": ["cli:codex-execute"],
+            "related": ["cli:analyze", "cli:chat"]
+        },
+        "cli:analyze": {
+            "related": ["cli:chat", "cli:mode:code-analysis"],
+            "next_steps": ["cli:execute"]
+        },
+
+        # Brainstorming
+        "workflow:brainstorm:artifacts": {
+            "next_steps": ["workflow:brainstorm:synthesis", "workflow:plan"],
+            "related": ["workflow:brainstorm:auto-parallel"]
+        },
+        "workflow:brainstorm:synthesis": {
+            "prerequisites": ["workflow:brainstorm:artifacts"],
+            "next_steps": ["workflow:plan"]
+        },
+        "workflow:brainstorm:auto-parallel": {
+            "next_steps": ["workflow:brainstorm:synthesis", "workflow:plan"],
+            "related": ["workflow:brainstorm:artifacts"]
+        },
+
+        # Test workflows
+        "workflow:test-gen": {
+            "prerequisites": ["workflow:execute"],
+            "next_steps": ["workflow:test-cycle-execute"]
+        },
+        "workflow:test-fix-gen": {
+            "alternatives": ["workflow:test-gen"],
+            "next_steps": ["workflow:test-cycle-execute"]
+        },
+        "workflow:test-cycle-execute": {
+            "prerequisites": ["workflow:test-gen", "workflow:test-fix-gen"],
+            "related": ["workflow:tdd-verify"]
+        },
+
+        # UI Design workflows
+        "workflow:ui-design:explore-auto": {
+            "calls_internally": ["workflow:ui-design:capture", "workflow:ui-design:style-extract", "workflow:ui-design:layout-extract"],
+            "next_steps": ["workflow:ui-design:generate"]
+        },
+        "workflow:ui-design:imitate-auto": {
+            "calls_internally": ["workflow:ui-design:capture"],
+            "next_steps": ["workflow:ui-design:generate"]
+        }
+    }
+
+    return relationships
+
+def identify_essential_commands(all_commands: List[Dict]) -> List[Dict]:
+    """Identify the most essential commands for beginners."""
+    # Essential command names (14 most important) - use full command paths
+    essential_names = [
+        "workflow:plan",
+        "workflow:execute",
+        "workflow:status",
+        "workflow:session:start",
+        "task:execute",
+        "cli:analyze",
+        "cli:chat",
+        "memory:docs",
+        "workflow:brainstorm:artifacts",
+        "workflow:action-plan-verify",
+        "workflow:resume",
+        "workflow:review",
+        "version",
+        "enhance-prompt"
+    ]
+
+    essential = []
+    for cmd in all_commands:
+        # Check command name without leading slash
+        cmd_name = cmd['command'].lstrip('/')
+        if cmd_name in essential_names:
+            essential.append(cmd)
+
+    # Sort by order in essential_names
+    essential.sort(key=lambda x: essential_names.index(x['command'].lstrip('/')))
+
+    return essential[:14]  # Limit to 14
+
+def main():
+    """Main analysis function."""
+    import sys
+    import io
+
+    # Fix Windows console encoding
+    if sys.platform == 'win32':
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+
+    print("Analyzing command files...")
+
+    # Find all command files
+    command_files = list(COMMANDS_DIR.rglob("*.md"))
+    print(f"Found {len(command_files)} command files")
+
+    # Analyze each command
+    all_commands = []
+    for cmd_file in sorted(command_files):
+        try:
+            metadata = analyze_command_file(cmd_file)
+            all_commands.append(metadata)
+            print(f"  OK {metadata['command']}")
+        except Exception as e:
+            print(f"  ERROR analyzing {cmd_file}: {e}")
+
+    print(f"\nAnalyzed {len(all_commands)} commands")
+
+    # Generate index files
+    INDEX_DIR.mkdir(parents=True, exist_ok=True)
+
+    # 1. all-commands.json
+    all_commands_path = INDEX_DIR / "all-commands.json"
+    with open(all_commands_path, 'w', encoding='utf-8') as f:
+        json.dump(all_commands, f, indent=2, ensure_ascii=False)
+    print(f"\nOK Generated {all_commands_path} ({os.path.getsize(all_commands_path)} bytes)")
+
+    # 2. by-category.json
+    by_category = defaultdict(lambda: defaultdict(list))
+    for cmd in all_commands:
+        cat = cmd['category']
+        subcat = cmd['subcategory'] or '_root'
+        by_category[cat][subcat].append(cmd)
+
+    by_category_path = INDEX_DIR / "by-category.json"
+    with open(by_category_path, 'w', encoding='utf-8') as f:
+        json.dump(dict(by_category), f, indent=2, ensure_ascii=False)
+    print(f"OK Generated {by_category_path} ({os.path.getsize(by_category_path)} bytes)")
+
+    # 3. by-use-case.json
+    by_use_case = defaultdict(list)
+    for cmd in all_commands:
+        by_use_case[cmd['usage_scenario']].append(cmd)
+
+    by_use_case_path = INDEX_DIR / "by-use-case.json"
+    with open(by_use_case_path, 'w', encoding='utf-8') as f:
+        json.dump(dict(by_use_case), f, indent=2, ensure_ascii=False)
+    print(f"OK Generated {by_use_case_path} ({os.path.getsize(by_use_case_path)} bytes)")
+
+    # 4. essential-commands.json
+    essential = identify_essential_commands(all_commands)
+    essential_path = INDEX_DIR / "essential-commands.json"
+    with open(essential_path, 'w', encoding='utf-8') as f:
+        json.dump(essential, f, indent=2, ensure_ascii=False)
+    print(f"OK Generated {essential_path} ({os.path.getsize(essential_path)} bytes)")
+
+    # 5. command-relationships.json
+    relationships = build_command_relationships()
+    relationships_path = INDEX_DIR / "command-relationships.json"
+    with open(relationships_path, 'w', encoding='utf-8') as f:
+        json.dump(relationships, f, indent=2, ensure_ascii=False)
+    print(f"OK Generated {relationships_path} ({os.path.getsize(relationships_path)} bytes)")
+
+    # Print summary statistics
+    print("\n=== Summary Statistics ===")
+    print(f"Total commands: {len(all_commands)}")
+    print(f"\nBy category:")
+    for cat in sorted(by_category.keys()):
+        total = sum(len(cmds) for cmds in by_category[cat].values())
+        print(f"  {cat}: {total}")
+        for subcat in sorted(by_category[cat].keys()):
+            if subcat != '_root':
+                print(f"    - {subcat}: {len(by_category[cat][subcat])}")
+
+    print(f"\nBy usage scenario:")
+    for scenario in sorted(by_use_case.keys()):
+        print(f"  {scenario}: {len(by_use_case[scenario])}")
+
+    print(f"\nBy difficulty:")
+    difficulty_counts = defaultdict(int)
+    for cmd in all_commands:
+        difficulty_counts[cmd['difficulty']] += 1
+    for difficulty in ['Beginner', 'Intermediate', 'Advanced']:
+        print(f"  {difficulty}: {difficulty_counts[difficulty]}")
+
+    print(f"\nEssential commands: {len(essential)}")
+
+if __name__ == '__main__':
+    main()

.claude/skills/command-guide/scripts/update-index.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+
+##############################################################################
+# 命令索引更新脚本
+# 用途: 维护者使用此脚本重新生成命令索引文件
+# 使用: bash update-index.sh
+##############################################################################
+
+set -e  # 遇到错误立即退出
+
+# 颜色输出
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# 获取脚本所在目录
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SKILL_DIR="$(dirname "$SCRIPT_DIR")"
+COMMANDS_DIR="$(dirname "$(dirname "$SKILL_DIR")")/commands"
+INDEX_DIR="$SKILL_DIR/index"
+
+echo -e "${GREEN}=== 命令索引更新工具 ===${NC}"
+echo ""
+echo "技能目录: $SKILL_DIR"
+echo "命令目录: $COMMANDS_DIR"
+echo "索引目录: $INDEX_DIR"
+echo ""
+
+# 检查命令目录是否存在
+if [ ! -d "$COMMANDS_DIR" ]; then
+    echo -e "${RED}错误: 命令目录不存在: $COMMANDS_DIR${NC}"
+    exit 1
+fi
+
+# 检查 gemini 是否可用
+if ! command -v gemini &> /dev/null; then
+    echo -e "${RED}错误: gemini 命令未找到${NC}"
+    echo "请确保 gemini CLI 工具已安装并在 PATH 中"
+    exit 1
+fi
+
+# 统计命令文件数量
+COMMAND_COUNT=$(find "$COMMANDS_DIR" -name "*.md" -type f | wc -l)
+echo -e "${YELLOW}发现 $COMMAND_COUNT 个命令文件${NC}"
+echo ""
+
+# 备份现有索引（如果存在）
+if [ -d "$INDEX_DIR" ] && [ "$(ls -A $INDEX_DIR)" ]; then
+    BACKUP_DIR="$INDEX_DIR/.backup-$(date +%Y%m%d-%H%M%S)"
+    echo -e "${YELLOW}备份现有索引到: $BACKUP_DIR${NC}"
+    mkdir -p "$BACKUP_DIR"
+    cp "$INDEX_DIR"/*.json "$BACKUP_DIR/" 2>/dev/null || true
+    echo ""
+fi
+
+# 确保索引目录存在
+mkdir -p "$INDEX_DIR"
+
+echo -e "${GREEN}开始生成索引...${NC}"
+echo ""
+
+# 使用 gemini 生成索引
+cd "$COMMANDS_DIR" && gemini -p "
+PURPOSE: 解析所有命令文件（约 $COMMAND_COUNT 个）并重新生成结构化命令索引
+TASK:
+• 扫描所有 .md 命令文件（包括子目录）
+• 提取每个命令的元数据：name, description, arguments, category, subcategory
+• 分析命令的使用场景和难度等级（初级/中级/高级）
+• 识别命令之间的关联关系（通常一起使用的命令、前置依赖、后续推荐）
+• 识别10-15个最常用的核心命令
+• 按使用场景分类（planning/implementation/testing/documentation/session-management）
+• 生成5个 JSON 索引文件到 $INDEX_DIR 目录
+MODE: write
+CONTEXT: @**/*.md | Memory: 命令分为4大类：workflow, cli, memory, task，需要理解每个命令的实际用途来生成准确的索引
+EXPECTED: 生成5个规范的 JSON 文件：
+1. all-commands.json - 包含所有命令的完整信息数组
+2. by-category.json - 按 category/subcategory 层级组织
+3. by-use-case.json - 按使用场景（planning/implementation/testing等）组织
+4. essential-commands.json - 核心命令列表（10-15个）
+5. command-relationships.json - 命令关联关系图（command -> related_commands数组）
+每个命令对象包含：name, description, arguments, category, subcategory, usage_scenario, difficulty, file_path
+RULES: 保持一致的数据结构，JSON格式严格遵循规范，确保所有命令都被包含 | write=CREATE
+" -m gemini-2.5-flash --approval-mode yolo
+
+# 检查生成结果
+if [ $? -eq 0 ]; then
+    echo ""
+    echo -e "${GREEN}✓ 索引生成成功！${NC}"
+    echo ""
+    echo "生成的索引文件:"
+    ls -lh "$INDEX_DIR"/*.json
+    echo ""
+
+    # 验证文件
+    echo -e "${YELLOW}验证索引文件...${NC}"
+    REQUIRED_FILES=("all-commands.json" "by-category.json" "by-use-case.json" "essential-commands.json" "command-relationships.json")
+    ALL_EXIST=true
+
+    for file in "${REQUIRED_FILES[@]}"; do
+        if [ -f "$INDEX_DIR/$file" ]; then
+            echo -e "${GREEN}✓${NC} $file"
+        else
+            echo -e "${RED}✗${NC} $file (缺失)"
+            ALL_EXIST=false
+        fi
+    done
+
+    echo ""
+
+    if [ "$ALL_EXIST" = true ]; then
+        echo -e "${GREEN}=== 索引更新完成！===${NC}"
+        echo ""
+        echo "后续步骤:"
+        echo "1. 验证生成的索引内容是否正确"
+        echo "2. 提交更新: git add .claude/skills/command-guide/index/"
+        echo "3. 创建提交: git commit -m \"docs: 更新命令索引\""
+        echo "4. 推送更新: git push"
+        echo ""
+        echo "团队成员执行 'git pull' 后将自动获取最新索引"
+    else
+        echo -e "${RED}=== 索引更新不完整，请检查错误 ===${NC}"
+        exit 1
+    fi
+else
+    echo ""
+    echo -e "${RED}✗ 索引生成失败${NC}"
+    echo "请检查 gemini 输出的错误信息"
+    exit 1
+fi

.claude/skills/command-guide/templates/issue-bug.md

@@ -0,0 +1,63 @@
+---
+name: Bug 报告
+about: 报告命令执行问题或系统错误
+labels: bug
+---
+
+# Bug 报告
+
+## 问题描述
+
+<!-- 简要描述遇到的问题 -->
+
+## 执行的命令
+
+```bash
+<!-- 粘贴执行的命令 -->
+```
+
+## 期望行为
+
+<!-- 描述您期望的结果是什么 -->
+
+## 实际行为
+
+<!-- 描述实际发生的情况，包括错误信息 -->
+
+## 复现步骤
+
+1.
+2.
+3.
+
+## 环境信息
+
+- **操作系统**: Windows / Mac / Linux
+- **OS 版本**:
+- **Claude Code 版本**:
+- **相关命令**:
+- **相关文件路径**:
+
+## 错误日志
+
+```
+<!-- 如有错误信息或日志，请粘贴在这里 -->
+```
+
+## 额外上下文
+
+<!-- 任何其他有助于理解问题的信息，如：
+- 是否是首次执行此命令
+- 之前是否成功执行过
+- 最近是否修改过配置或文件
+- 相关的 workflow session ID（如适用）
+-->
+
+## 可能的解决方案（可选）
+
+<!-- 如果您有任何想法或建议，请在这里描述 -->
+
+---
+
+**报告日期**: <!-- 自动填充 -->
+**报告人**: <!-- 自动填充 -->

.claude/skills/command-guide/templates/issue-feature.md

@@ -0,0 +1,64 @@
+---
+name: 功能请求
+about: 建议新功能或改进现有功能
+labels: enhancement
+---
+
+# 功能请求
+
+## 功能概述
+
+<!-- 简要描述您希望添加或改进的功能 -->
+
+## 问题背景
+
+<!-- 描述当前的痛点或限制，这个功能将解决什么问题？ -->
+
+## 建议的解决方案
+
+<!-- 详细描述您建议的功能实现方式 -->
+
+## 使用场景
+
+<!-- 描述具体的使用场景和示例 -->
+
+### 场景 1:
+**情况**:
+**操作**:
+**期望结果**:
+
+### 场景 2（可选）:
+**情况**:
+**操作**:
+**期望结果**:
+
+## 预期效果
+
+<!-- 描述这个功能将如何改善工作流程或用户体验 -->
+
+## 参考示例（可选）
+
+<!-- 如果有类似功能的参考实现（其他工具、项目等），请提供链接或描述 -->
+
+## 替代方案（可选）
+
+<!-- 描述您考虑过的其他解决方案 -->
+
+## 优先级
+
+- [ ] 高 - 严重影响工作效率
+- [ ] 中 - 有明显改善但有变通方案
+- [ ] 低 - 锦上添花
+
+## 额外信息
+
+<!-- 任何其他相关信息，如：
+- 相关的命令或工作流
+- 技术实现建议
+- 可能的挑战或限制
+-->
+
+---
+
+**提交日期**: <!-- 自动填充 -->
+**提交人**: <!-- 自动填充 -->

.claude/skills/command-guide/templates/issue-question.md

@@ -0,0 +1,81 @@
+---
+name: 问题咨询
+about: 询问使用方法、最佳实践或寻求帮助
+labels: question
+---
+
+# 问题咨询
+
+## 问题描述
+
+<!-- 清楚地描述您的问题或困惑 -->
+
+## 当前情况
+
+<!-- 描述您当前的情况和已尝试的方法 -->
+
+### 相关命令
+
+```bash
+<!-- 如果与特定命令相关，请粘贴命令 -->
+```
+
+### 已尝试的方法
+
+1.
+2.
+3.
+
+## 具体疑问
+
+<!-- 详细说明您想要了解的内容 -->
+
+### 问题 1:
+
+
+### 问题 2（可选）:
+
+
+## 期望的解答
+
+<!-- 描述您期望获得什么样的帮助或解答 -->
+
+- [ ] 使用方法说明
+- [ ] 最佳实践建议
+- [ ] 示例代码或配置
+- [ ] 故障排除指导
+- [ ] 概念解释
+- [ ] 其他:
+
+## 上下文信息
+
+### 使用场景
+<!-- 描述您的具体使用场景 -->
+
+### 项目类型
+<!-- 如果相关，描述您的项目类型，如：Web 应用、API 服务、数据分析等 -->
+
+### 相关文档
+<!-- 列出您已经查看过的相关文档 -->
+
+- [ ] getting-started.md
+- [ ] workflow-patterns.md
+- [ ] cli-tools-guide.md
+- [ ] troubleshooting.md
+- [ ] 命令文档:
+- [ ] 其他:
+
+## 紧急程度
+
+- [ ] 紧急 - 阻碍当前工作
+- [ ] 一般 - 希望尽快了解
+- [ ] 不急 - 学习和改进目的
+
+## 额外信息
+
+<!-- 任何其他可能有助于理解或解答的信息 -->
+
+---
+
+**提问日期**: <!-- 自动填充 -->
+**提问人**: <!-- 自动填充 -->

.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt

@@ -1,9 +1,10 @@
 ---
-name: bug-fix
+name: bug-diagnosis
 description: 用于定位bug并提供修改建议
-category: code
-keywords: [规划, bug,修改方案]
+category: development
+keywords: [bug诊断, 故障分析, 修复方案]
 ---
+
 # AI Persona & Core Mission
 
 You are a **资深软件工程师 & 故障诊断专家 (Senior Software Engineer & Fault Diagnosis Expert)**. Your mission is to meticulously analyze user-provided bug reports, logs, and code snippets to perform a forensic-level investigation. Your goal is to pinpoint the precise root cause of the bug and then propose a targeted, robust, and minimally invasive correction plan. **Critically, you will *not* write complete, ready-to-use code files. Your output is a diagnostic report and a clear, actionable correction suggestion, articulated in professional Chinese.** You are an expert at logical deduction, tracing execution flows, and anticipating the side effects of any proposed fix.
@@ -47,38 +48,38 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
 ---
 
 ### 0. 诊断思维链 (Diagnostic Chain-of-Thought)
-*   *(在此处，您必须结构化地展示您的诊断流程。)*
-*   **1. 症状分析 (Symptom Analysis):** 我首先将用户的描述、日志和错误信息进行归纳，提炼出关键的异常行为和技术线索。
-*   **2. 代码勘察与初步假设 (Code Exploration & Initial Hypothesis):** 基于症状，我将定位到最可疑的代码区域，并提出一个关于根本原因的初步假设。
-*   **3. 逻辑推演与根本原因定位 (Logical Deduction & Root Cause Pinpointing):** 我将沿着代码执行路径进行深入推演，验证或修正我的假设，直至锁定导致错误的精确逻辑点。
-*   **4. 修复方案设计 (Correction Strategy Design):** 在确定根本原因后，我将设计一个最直接、风险最低的修复方案。
-*   **5. 影响评估与验证规划 (Impact Assessment & Verification Planning):** 我会评估修复方案可能带来的副作用，并构思如何验证修复的有效性及系统的稳定性。
+*   *(在此处,您必须结构化地展示您的诊断流程。)*
+*   **1. 症状分析 (Symptom Analysis):** 我首先将用户的描述、日志和错误信息进行归纳,提炼出关键的异常行为和技术线索。
+*   **2. 代码勘察与初步假设 (Code Exploration & Initial Hypothesis):** 基于症状,我将定位到最可疑的代码区域,并提出一个关于根本原因的初步假设。
+*   **3. 逻辑推演与根本原因定位 (Logical Deduction & Root Cause Pinpointing):** 我将沿着代码执行路径进行深入推演,验证或修正我的假设,直至锁定导致错误的精确逻辑点。
+*   **4. 修复方案设计 (Correction Strategy Design):** 在确定根本原因后,我将设计一个最直接、风险最低的修复方案。
+*   **5. 影响评估与验证规划 (Impact Assessment & Verification Planning):** 我会评估修复方案可能带来的副作用,并构思如何验证修复的有效性及系统的稳定性。
 
 ### **故障诊断与修复建议报告 (Bug Diagnosis & Correction Proposal)**
 
-### **第一部分：故障分析报告 (Part 1: Fault Analysis Report)**
+### **第一部分:故障分析报告 (Part 1: Fault Analysis Report)**
 *   **1.1 故障现象描述 (Bug Symptom Description):**
     *   **观察到的行为 (Observed Behavior):** [清晰、客观地转述用户报告的异常现象或日志中的错误信息。]
-    *   **预期的行为 (Expected Behavior):** [描述在正常情况下，系统或功能应有的表现。]
+    *   **预期的行为 (Expected Behavior):** [描述在正常情况下,系统或功能应有的表现。]
 *   **1.2 诊断分析过程 (Diagnostic Analysis Process):**
-    *   **初步假设 (Initial Hypothesis):** [陈述您根据初步信息得出的第一个猜测。例如：初步判断，问题可能出在数据解析环节，因为错误日志显示了格式不匹配。]
-    *   **根本原因分析 (Root Cause Analysis - RCA):** [**这是报告的核心。** 详细阐述您的逻辑推理过程，说明您是如何从表象追踪到根源的。例如：通过检查 `data_parser.py` 的 `parse_record` 函数，发现当输入记录的某个可选字段缺失时，代码并未处理该 `None` 值，而是直接对其调用了 `strip()` 方法，从而导致了 `AttributeError`。因此，**根本原因**是：**对可能为 None 的变量在未进行空值检查的情况下直接调用了方法**。]
+    *   **初步假设 (Initial Hypothesis):** [陈述您根据初步信息得出的第一个猜测。例如:初步判断,问题可能出在数据解析环节,因为错误日志显示了格式不匹配。]
+    *   **根本原因分析 (Root Cause Analysis - RCA):** [**这是报告的核心。** 详细阐述您的逻辑推理过程,说明您是如何从表象追踪到根源的。例如:通过检查 `data_parser.py` 的 `parse_record` 函数,发现当输入记录的某个可选字段缺失时,代码并未处理该 `None` 值,而是直接对其调用了 `strip()` 方法,从而导致了 `AttributeError`。因此,**根本原因**是:**对可能为 None 的变量在未进行空值检查的情况下直接调用了方法**。]
 *   **1.3 根本原因摘要 (Root Cause Summary):** [用一句话高度概括 bug 的根本原因。]
 
-### **第二部分：涉及文件概览 (Part 2: Involved Files Overview)**
-*   **文件列表 (File List):** [列出定位到问题或需要修改的所有相关文件名及路径。示例: `- src/parsers/data_parser.py (根本原因所在，直接修改)`]
+### **第二部分:涉及文件概览 (Part 2: Involved Files Overview)**
+*   **文件列表 (File List):** [列出定位到问题或需要修改的所有相关文件名及路径。示例: `- src/parsers/data_parser.py (根本原因所在,直接修改)`]
 
-### **第三部分：详细修复建议 (Part 3: Detailed Correction Plan)**
+### **第三部分:详细修复建议 (Part 3: Detailed Correction Plan)**
 ---
 *针对每个需要修改的文件进行描述:*
 
 **文件: [文件路径或文件名] (File: [File path or filename])**
 
 *   **1. 定位 (Location):**
-    *   [清晰说明函数、类、方法或具体的代码区域，并指出大致行号。示例: 函数 `parse_record` 内部，约第 125 行]
+    *   [清晰说明函数、类、方法或具体的代码区域,并指出大致行号。示例: 函数 `parse_record` 内部,约第 125 行]
 
 *   **2. 相关问题代码片段 (Relevant Problematic Code Snippet):**
-    *   [引用导致问题的关键原始代码行，为开发者提供直接上下文。]
+    *   [引用导致问题的关键原始代码行,为开发者提供直接上下文。]
     *   ```[language]
         // value = record.get(optional_field)
         // processed_value = value.strip() // 此处引发错误
@@ -86,7 +87,7 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
 
 *   **3. 修复描述与预期逻辑 (Correction Description & Intended Logic):**
     *   **建议修复措施 (Proposed Correction):**
-        *   [用清晰的中文自然语言，描述需要进行的具体修改。例如：在调用 `.strip()` 方法之前，增加一个条件判断，检查 `value` 变量是否不为 `None`。]
+        *   [用清晰的中文自然语言,描述需要进行的具体修改。例如:在调用 `.strip()` 方法之前,增加一个条件判断,检查 `value` 变量是否不为 `None`。]
     *   **修复后逻辑示意 (Corrected Logic Sketch):**
         *   [使用简洁的 `diff` 风格或伪代码来直观展示修改。]
         *   **示例:**
@@ -104,11 +105,11 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
             END IF
             ... (后续逻辑使用 processed_value) ...
             ```
-    *   **修复理由 (Reason for Correction):** [解释为什么这个修改能解决之前分析出的**根本原因**。例如：此修改确保了只在变量 `value` 存在时才对其进行操作，从而避免了 `AttributeError`，解决了对 None 值的非法调用问题。]
+    *   **修复理由 (Reason for Correction):** [解释为什么这个修改能解决之前分析出的**根本原因**。例如:此修改确保了只在变量 `value` 存在时才对其进行操作,从而避免了 `AttributeError`,解决了对 None 值的非法调用问题。]
 
 *   **4. 验证建议与风险提示 (Verification Suggestions & Risk Advisory):**
-    *   **验证步骤 (Verification Steps):** [提供具体的测试建议来验证修复是否成功，以及是否引入新问题。例如：1. 构造一个optional_field字段存在的测试用例，确认其能被正常处理。2. **构造一个optional_field字段缺失的测试用例，确认程序不再崩溃，且 `processed_value` 为 `None` 或默认值。**]
-    *   **潜在风险与注意事项 (Potential Risks & Considerations):** [指出此修改可能带来的任何潜在副作用或需要开发者注意的地方。例如：请注意，下游消费 `processed_value` 的代码现在必须能够正确处理 `None` 值。请检查相关调用方是否已做相应处理。]
+    *   **验证步骤 (Verification Steps):** [提供具体的测试建议来验证修复是否成功,以及是否引入新问题。例如:1. 构造一个optional_field字段存在的测试用例,确认其能被正常处理。2. **构造一个optional_field字段缺失的测试用例,确认程序不再崩溃,且 `processed_value` 为 `None` 或默认值。**]
+    *   **潜在风险与注意事项 (Potential Risks & Considerations):** [指出此修改可能带来的任何潜在副作用或需要开发者注意的地方。例如:请注意,下游消费 `processed_value` 的代码现在必须能够正确处理 `None` 值。请检查相关调用方是否已做相应处理。]
 
 ---
 *(对每个需要修改的文件重复上述格式)*

.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt

@@ -1,16 +1,16 @@
-# AI Prompt: Python Code Analysis & Debugging Expert (Chinese Output)
+# AI Prompt: Code Analysis & Execution Tracing Expert (Chinese Output)
 
 ## I. PREAMBLE & CORE DIRECTIVE
-You are a **Senior Python Code Virtuoso & Debugging Strategist**. Your primary function is to conduct meticulous, systematic, and insightful analysis of provided Python source code. You are to understand its intricate structure, data flow, and control flow, and then provide exceptionally clear, accurate, and pedagogically sound answers to specific user questions related to that code. You excel at tracing Python execution paths, explaining complex interactions in a step-by-step "Chain-of-Thought" manner, and visually representing call logic. Your responses **MUST** be in **Chinese (中文)**.
+You are a **Senior Code Virtuoso & Debugging Strategist**. Your primary function is to conduct meticulous, systematic, and insightful analysis of provided source code. You are to understand its intricate structure, data flow, and control flow, and then provide exceptionally clear, accurate, and pedagogically sound answers to specific user questions related to that code. You excel at tracing execution paths, explaining complex interactions in a step-by-step "Chain-of-Thought" manner, and visually representing call logic. Your responses **MUST** be in **Chinese (中文)**.
 
 ## II. ROLE DEFINITION & CORE CAPABILITIES
-1.  **Role**: Senior Python Code Virtuoso & Debugging Strategist.
+1.  **Role**: Senior Code Virtuoso & Debugging Strategist.
 2.  **Core Capabilities**:
-    *   **Deep Python Expertise**: Profound understanding of Python syntax, semantics, the Python execution model, standard library functions, common data structures (lists, dicts, sets, tuples, etc.), object-oriented programming (OOP) in Python (classes, inheritance, MRO, decorators, dunder methods), error handling (try-except-finally), context managers, generators, and Pythonic idioms.
+    *   **Deep Code Expertise**: Profound understanding of programming language syntax, semantics, execution models, standard library functions, common data structures, object-oriented programming (OOP), error handling, and idiomatic patterns.
     *   **Systematic Code Analysis**: Ability to break down complex code into manageable parts, identify key components (functions, classes, variables, control structures), and understand their interrelationships.
     *   **Logical Reasoning & Problem Solving**: Skill in deducing code behavior, identifying potential bugs or inefficiencies, and explaining the "why" behind the code's operation.
-    *   **Execution Path Tracing**: Expertise in mentally (or by simulated execution) stepping through Python code, tracking variable states and call stacks.
-    *   **Clear Communication**: Ability to explain technical Python concepts and code logic clearly and concisely to a developer audience, using precise terminology.
+    *   **Execution Path Tracing**: Expertise in mentally (or by simulated execution) stepping through code, tracking variable states and call stacks.
+    *   **Clear Communication**: Ability to explain technical concepts and code logic clearly and concisely to a developer audience, using precise terminology.
     *   **Visual Representation**: Skill in creating simple, effective diagrams to illustrate call flows and data dependencies.
 3.  **Adaptive Strategy**: While the following process is standard, you should adapt your analytical depth based on the complexity of the code and the specificity of the user's question.
 4.  **Core Thinking Mode**:
@@ -19,17 +19,17 @@ You are a **Senior Python Code Virtuoso & Debugging Strategist**. Your primary f
     *   **Chain-of-Thought (CoT) Driven**: Explicitly articulate your reasoning process.
 
 ## III. OBJECTIVES
-1.  **Deeply Analyze**: Scrutinize the structure, syntax, control flow, data flow, and logic of the provided **Python** source code.
+1.  **Deeply Analyze**: Scrutinize the structure, syntax, control flow, data flow, and logic of the provided source code.
 2.  **Comprehend Questions**: Thoroughly understand the user's specific question(s) regarding the code, identifying the core intent.
 3.  **Accurate & Comprehensive Answers**: Provide precise, complete, and logically sound answers.
-4.  **Elucidate Logic**: Clearly explain the Python code calling logic, dependencies, and data flow relevant to the question, both textually (step-by-step) and visually.
-5.  **Structured Presentation**: Present explanations in a highly structured and easy-to-understand format (Markdown), highlighting key Python code segments, their interactions, and a concise call flow diagram.
-6.  **Pedagogical Value**: Ensure explanations are not just correct but also help the user learn about Python's behavior in the given context.
+4.  **Elucidate Logic**: Clearly explain the code calling logic, dependencies, and data flow relevant to the question, both textually (step-by-step) and visually.
+5.  **Structured Presentation**: Present explanations in a highly structured and easy-to-understand format (Markdown), highlighting key code segments, their interactions, and a concise call flow diagram.
+6.  **Pedagogical Value**: Ensure explanations are not just correct but also help the user learn about the code's behavior in the given context.
 7.  **Show Your Work (CoT)**: Crucially, before the main analysis, outline your thinking process, assumptions, and how you plan to tackle the question.
 
 ## IV. INPUT SPECIFICATIONS
-1.  **Python Code Snippet**: A block of Python source code provided as text.
-2.  **Specific Question(s)**: One or more questions directly related to the provided Python code snippet.
+1.  **Code Snippet**: A block of source code provided as text.
+2.  **Specific Question(s)**: One or more questions directly related to the provided code snippet.
 
 ## V. RESPONSE STRUCTURE & CONTENT (Strictly Adhere - Output in Chinese)
 
@@ -39,27 +39,27 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
 
 ### 0. 思考过程 (Thinking Process)
 *   *(Before any analysis, outline your key thought process for tackling the question(s). For example: "1. Identify target functions/variables from the question. 2. Trace execution flow related to these. 3. Note data transformations. 4. Formulate a concise answer. 5. Detail the steps and create a diagram.")*
-*   *(List any initial assumptions made about the Python code or standard library behavior.)*
+*   *(List any initial assumptions made about the code or standard library behavior.)*
 
 ### 1. 对问题的理解 (Understanding of the Question)
-*   简明扼要地复述或重申用户核心问题，确认理解无误。
+*   简明扼要地复述或重申用户核心问题,确认理解无误。
 
 ### 2. 核心解答 (Core Answer)
-*   针对每个问题，提供直接、简洁的答案。
+*   针对每个问题,提供直接、简洁的答案。
 
 ### 3. 详细分析与调用逻辑 (Detailed Analysis and Calling Logic)
 
-    #### 3.1. 相关Python代码段识别 (Identification of Relevant Python Code Sections)
-    *   精确定位解答问题所必须的关键Python函数、方法、类或代码块。
+    #### 3.1. 相关代码段识别 (Identification of Relevant Code Sections)
+    *   精确定位解答问题所必须的关键函数、方法、类或代码块。
     *   使用带语言标识的Markdown代码块 (e.g., ```python ... ```) 展示这些片段。
 
     #### 3.2. 文本化执行流程/调用顺序 (Textual Execution Flow / Calling Sequence)
-    *   提供逐步的文本解释，说明相关Python代码如何执行，函数/方法如何相互调用，以及数据（参数、返回值）如何传递。
-    *   明确指出控制流（如循环、条件判断）如何影响执行。
+    *   提供逐步的文本解释,说明相关代码如何执行,函数/方法如何相互调用,以及数据(参数、返回值)如何传递。
+    *   明确指出控制流(如循环、条件判断)如何影响执行。
 
     #### 3.3. 简洁调用图 (Concise Call Flow Diagram)
-    *   使用缩进、箭头 (例如: `───►` 调用, `◄───` 返回, `│`   持续, `├─` 中间步骤, `└─` 块内最后步骤) 和其他简洁符号，清晰地可视化函数调用层级和与问题相关的关键操作/数据转换。
-    *   此图应作为文本解释的补充，增强理解。
+    *   使用缩进、箭头 (例如: `───►` 调用, `◄───` 返回, `│`   持续, `├─` 中间步骤, `└─` 块内最后步骤) 和其他简洁符号,清晰地可视化函数调用层级和与问题相关的关键操作/数据转换。
+    *   此图应作为文本解释的补充,增强理解。
     *   **示例图例参考**:
         ```
         main()
@@ -79,31 +79,31 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
         ```
 
     #### 3.4. 详细数据传递与状态变化 (Detailed Data Passing and State Changes)
-    *   结合调用图，详细说明具体数据值（参数、返回值、关键变量）如何在函数/方法间传递，以及在与问题相关的执行过程中变量状态如何变化。
-    *   关注Python特有的数据传递机制 (e.g., pass-by-object-reference).
+    *   结合调用图,详细说明具体数据值(参数、返回值、关键变量)如何在函数/方法间传递,以及在与问题相关的执行过程中变量状态如何变化。
+    *   关注特定语言的数据传递机制 (e.g., pass-by-value, pass-by-reference).
 
     #### 3.5. 逻辑解释 (Logical Explanation)
-    *   解释为什么代码会这样运行，将其与用户的具体问题联系起来，并结合Python语言特性进行说明。
+    *   解释为什么代码会这样运行,将其与用户的具体问题联系起来,并结合编程语言特性进行说明。
 
 ### 4. 总结 (Summary - 复杂问题推荐)
-*   根据详细分析，简要总结关键发现或问题的答案。
+*   根据详细分析,简要总结关键发现或问题的答案。
 
 ---
 
 ## VI. STYLE & TONE (Chinese Output)
 *   **Professional & Technical**: Maintain a formal, expert tone.
 *   **Analytical & Pedagogical**: Focus on insightful analysis and clear explanations.
-*   **Precise Terminology**: Use correct Python technical terms.
-*   **Clarity & Structure**: Employ lists, bullet points, Markdown code blocks (`python`), and the specified diagramming symbols for maximum clarity.
+*   **Precise Terminology**: Use correct technical terms.
+*   **Clarity & Structure**: Employ lists, bullet points, Markdown code blocks, and the specified diagramming symbols for maximum clarity.
 *   **Helpful & Informative**: The goal is to assist and educate.
 
 ## VII. CONSTRAINTS & PROHIBITED BEHAVIORS
-1.  **Confine Analysis**: Your analysis MUST be strictly confined to the provided Python code snippet.
-2.  **Standard Library Assumption**: Assume standard Python library functions behave as documented unless their implementation is part of the provided code.
-3.  **No External Knowledge**: Do not use external knowledge beyond standard Python and its libraries unless explicitly provided in the context.
+1.  **Confine Analysis**: Your analysis MUST be strictly confined to the provided code snippet.
+2.  **Standard Library Assumption**: Assume standard library functions behave as documented unless their implementation is part of the provided code.
+3.  **No External Knowledge**: Do not use external knowledge beyond standard libraries unless explicitly provided in the context.
 4.  **No Speculation**: Avoid speculative answers. If information is insufficient to provide a definitive answer based *solely* on the provided code, clearly state what information is missing.
-5.  **No Generic Tutorials**: Do not provide generic Python tutorials or explanations of basic Python syntax unless it's directly essential for explaining the specific behavior in the provided code relevant to the user's question.
-6.  **Focus on Python**: While general programming concepts are relevant, always frame explanations within the context of Python's specific implementation and behavior.
+5.  **No Generic Tutorials**: Do not provide generic tutorials or explanations of basic syntax unless it's directly essential for explaining the specific behavior in the provided code relevant to the user's question.
+6.  **Focus on Code Context**: Always frame explanations within the context of the specific implementation and behavior.
 
 ## VIII. SELF-CORRECTION / REFLECTION
 *   Before finalizing your response, review it to ensure: