release: v3.3.0 - CLI Tool Enhancements & Codex Multi-Step Execution

✨ Features:
- New /cli:codex-execute command for automated multi-step task execution
- Codex resume mechanism (codex exec "..." resume --last) for context continuity
- TodoWrite progress tracking for subtask execution
- Optional Git verification after each subtask (--verify-git flag)
- Automatic task JSON detection and loading
- Enhanced Codex agent configuration (.codex/AGENTS.md v2.1.0)

📚 Documentation:
- Streamlined CLI documentation (60% reduction in redundancy)
- Updated /cli:analyze, /cli:chat, /cli:execute commands
- Enhanced intelligent-tools-strategy.md with Codex resume patterns
- Unified command templates for Gemini/Qwen vs Codex
- Added Codex -i parameter documentation for image attachment

🔧 Technical:
- Multi-task prompt format (Single-Task & Multi-Task)
- Subtask coordination guidelines and best practices
- Enhanced MODE: auto with subtask execution flow
- Progress reporting for multi-step workflows

📦 Updates:
- Version bumped to 3.3.0 in README.md, README_CN.md
- Created .claude/version.json for version tracking
- Comprehensive CHANGELOG.md entry with all changes

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

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

.claude/agents/action-planning-agent.md

@@ -228,7 +228,7 @@ Generate individual `.task/IMPL-*.json` files with:
       "modification_points": ["Apply requirements"],
       "logic_flow": ["Load spec", "Analyze", "Implement", "Validate"]
     },
-    "target_files": ["file:function:lines"]
+    "target_files": ["file:function:lines", "path/to/NewFile.ts"]
   }
 }
 ```

.claude/commands/cli/analyze.md

@@ -17,185 +17,68 @@ allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
 Execute CLI tool analysis on codebase patterns, architecture, or code quality.
 
 **Supported Tools**: codex, gemini (default), qwen
+**Reference**: @~/.claude/workflows/intelligent-tools-strategy.md for complete tool details
 
 ## Execution Flow
 
-1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
+1. Parse tool selection (default: gemini)
-2. **If `--enhance` flag present**: Execute `/enhance-prompt "[analysis-target]"` and use enhanced output
+2. If `--enhance`: Execute `/enhance-prompt` first
-3. Parse analysis target (original or enhanced)
+3. Detect analysis type and select template
-4. Detect analysis type (pattern/architecture/security/quality)
+4. Build and execute command
-5. Build command for selected tool with template
+5. Return results
-6. Execute analysis
-7. Return results
-
-## Core Rules
-
-1. **Tool Selection**: Use `--tool` value or default to gemini
-2. **Enhance First (if flagged)**: Execute `/enhance-prompt` before analysis when `--enhance` present
-3. **Execute Immediately**: Build and run command without preliminary analysis
-4. **Template Selection**: Auto-select template based on keywords
-5. **Context Inclusion**: Always include CLAUDE.md in context
-6. **Direct Output**: Return tool output directly to user
-
-## Tool Selection
-
-| Tool | Wrapper | Best For | Permissions |
-|------|---------|----------|-------------|
-| **gemini** (default) | `~/.claude/scripts/gemini-wrapper` | Analysis, exploration, documentation | Read-only |
-| **qwen** | `~/.claude/scripts/qwen-wrapper` | Architecture, code generation | Read-only for analyze |
-| **codex** | `codex --full-auto exec` | Development analysis, deep inspection | `-s danger-full-access --skip-git-repo-check` |
 
 ## Enhancement Integration
 
-**When `--enhance` flag present**:
+**When `--enhance` flag present**: Execute `/enhance-prompt "[analysis-target]"` first, then use enhanced output (INTENT/CONTEXT/ACTION) to build the analysis command.
+
+
+## Command Template
+
+**Gemini/Qwen**:
 ```bash
-# Step 1: Enhance the prompt
+cd [dir] && ~/.claude/scripts/[gemini|qwen]-wrapper -p "
-SlashCommand(command="/enhance-prompt \"[analysis-target]\"")
+PURPOSE: [analysis goal]
-
+TASK: [specific task]
-# Step 2: Use enhanced output as analysis target
-# Enhanced output provides:
-# - INTENT: Clear technical goal
-# - CONTEXT: Session memory + patterns
-# - ACTION: Implementation steps
-# - ATTENTION: Critical constraints
-```
-
-**Example**:
-```bash
-# User: /gemini:analyze --enhance "fix auth issues"
-
-# Step 1: Enhance
-/enhance-prompt "fix auth issues"
-# Returns:
-# INTENT: Debug authentication failures
-# CONTEXT: JWT implementation in src/auth/, known token expiry issue
-# ACTION: Analyze token lifecycle → verify refresh flow → check middleware
-# ATTENTION: Preserve existing session management
-
-# Step 2: Analyze with enhanced context
-cd . && ~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: Debug authentication failures (from enhanced: JWT token lifecycle)
-TASK: Analyze token lifecycle, refresh flow, and middleware integration
-CONTEXT: @{src/auth/**/*} @{CLAUDE.md} Session context: known token expiry issue
-EXPECTED: Root cause analysis with file references
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/security.txt) | Focus on JWT token handling
-"
-```
-
-## Analysis Types
-
-| Type | Keywords | Template | Context |
-|------|----------|----------|---------|
-| **pattern** | pattern, hooks, usage | analysis/pattern.txt | Matched files + CLAUDE.md |
-| **architecture** | architecture, structure, design | analysis/architecture.txt | Full codebase + CLAUDE.md |
-| **security** | security, vulnerability, auth | analysis/security.txt | Matched files + CLAUDE.md |
-| **quality** | quality, test, coverage | analysis/quality.txt | Source + test files + CLAUDE.md |
-
-## Command Templates
-
-### Gemini (Default)
-```bash
-cd [target-dir] && ~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: [analysis goal from user input]
-TASK: [specific analysis task]
 CONTEXT: @{[file-patterns]} @{CLAUDE.md}
-EXPECTED: [expected output format]
+EXPECTED: [output format]
 RULES: $(cat ~/.claude/workflows/cli-templates/prompts/[category]/[template].txt) | [constraints]
 "
 ```
 
-### Qwen
+**Codex**:
 ```bash
-cd [target-dir] && ~/.claude/scripts/qwen-wrapper -p "
+codex -C [dir] --full-auto exec "
-PURPOSE: [analysis goal from user input]
+PURPOSE: [analysis goal]
-TASK: [specific analysis task]
+TASK: [specific task]
 CONTEXT: @{[file-patterns]} @{CLAUDE.md}
-EXPECTED: [expected output format]
+EXPECTED: [output format]
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/[category]/[template].txt) | [constraints]
+RULES: [constraints]
-"
-```
-
-### Codex
-```bash
-codex -C [target-dir] --full-auto exec "
-PURPOSE: [analysis goal from user input]
-TASK: [specific analysis task]
-CONTEXT: @{[file-patterns]} @{CLAUDE.md}
-EXPECTED: [expected output format]
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/[category]/[template].txt) | [constraints]
 " --skip-git-repo-check -s danger-full-access
+
+# With image attachment (e.g., UI screenshots, diagrams)
+codex -C [dir] -i screenshot.png --full-auto exec "..." --skip-git-repo-check -s danger-full-access
 ```
 
 ## Examples
 
-**Pattern Analysis (Gemini - default)**:
 ```bash
-cd . && ~/.claude/scripts/gemini-wrapper -p "
+/cli:analyze "authentication patterns"              # Gemini (default)
-PURPOSE: Analyze authentication patterns
+/cli:analyze --tool qwen "component architecture"   # Qwen architecture
-TASK: Identify auth implementation patterns and conventions
+/cli:analyze --tool codex "performance bottlenecks" # Codex deep analysis
-CONTEXT: @{**/*auth*} @{CLAUDE.md}
+/cli:analyze --enhance "fix auth issues"            # Enhanced prompt first
-EXPECTED: Pattern summary with file references
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt) | Focus on security
-"
-```
-
-**Architecture Review (Qwen)**:
-```bash
-# User: /cli:analyze --tool qwen "component architecture"
-
-cd . && ~/.claude/scripts/qwen-wrapper -p "
-PURPOSE: Review component architecture
-TASK: Analyze component structure and dependencies
-CONTEXT: @{src/**/*} @{CLAUDE.md}
-EXPECTED: Architecture diagram and integration points
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/architecture.txt) | Focus on modularity
-"
-```
-
-**Deep Inspection (Codex)**:
-```bash
-# User: /cli:analyze --tool codex "performance bottlenecks"
-
-codex -C . --full-auto exec "
-PURPOSE: Identify performance bottlenecks
-TASK: Deep analysis of performance issues
-CONTEXT: @{src/**/*} @{CLAUDE.md}
-EXPECTED: Performance metrics and optimization recommendations
-RULES: Focus on computational complexity and memory usage
-" --skip-git-repo-check -s danger-full-access
 ```
 
 ## File Pattern Logic
 
-**Keyword Matching**:
+Auto-detect file patterns from keywords:
 - "auth" → `@{**/*auth*}`
 - "component" → `@{src/components/**/*}`
 - "API" → `@{**/api/**/*}`
 - "test" → `@{**/*.test.*}`
-- Generic → `@{src/**/*}` or `@{**/*}`
+- Generic → `@{src/**/*}`
 
 ## Session Integration
 
-**Detect Active Session**: Check for `.workflow/.active-*` marker file
+- **Active Session**: Save results to `.workflow/WFS-[id]/.chat/analysis-[timestamp].md`
-
+- **No Session**: Return results directly to user
-**If Session Active**:
-- Save results to `.workflow/WFS-[id]/.chat/analysis-[timestamp].md`
-- Include session context in analysis
-
-**If No Session**:
-- Return results directly to user
-
-## Output Format
-
-Return Gemini's output directly, which includes:
-- File references (file:line format)
-- Code snippets
-- Pattern analysis
-- Recommendations
-
-## Error Handling
-
-- **Missing Template**: Use generic analysis prompt
-- **No Context**: Use `@{**/*}` as fallback
-- **Command Failure**: Report error and suggest manual command
 

.claude/commands/cli/chat.md

@@ -12,150 +12,81 @@ allowed-tools: SlashCommand(*), Bash(*)
 model: sonnet
 ---
 
-### 🚀 **Command Overview: `/cli:chat`**
+## Purpose
 
--   **Type**: CLI Tool Wrapper for Interactive Analysis
+Direct interaction with CLI tools for codebase analysis and Q&A.
--   **Purpose**: Direct interaction with CLI tools for codebase analysis
--   **Supported Tools**: codex, gemini (default), qwen
 
-### 📥 **Parameters & Usage**
+**Supported Tools**: codex, gemini (default), qwen
+**Reference**: @~/.claude/workflows/intelligent-tools-strategy.md for complete tool details
 
--   **`<inquiry>` (Required)**: Your question or analysis request
+## Parameters
--   **`--tool <codex|gemini|qwen>` (Optional)**: Select CLI tool (default: gemini)
--   **`--enhance` (Optional)**: Enhance inquiry with `/enhance-prompt` before execution
--   **`--all-files` (Optional)**: Includes the entire codebase in the analysis context
--   **`--save-session` (Optional)**: Saves the interaction to current workflow session directory
--   **File References**: Specify files or patterns using `@{path/to/file}` syntax
 
-### 🔄 **Execution Workflow**
+- `<inquiry>` (Required): Question or analysis request
+- `--tool <codex|gemini|qwen>` (Optional): Select CLI tool (default: gemini)
+- `--enhance` (Optional): Enhance inquiry with `/enhance-prompt` first
+- `--all-files` (Optional): Include entire codebase in context
+- `--save-session` (Optional): Save interaction to workflow session
 
-`Parse Tool` **->** `Parse Input` **->** `[Optional] Enhance` **->** `Assemble Context` **->** `Construct Prompt` **->** `Execute CLI Tool` **->** `(Optional) Save Session`
+## Execution Flow
 
-### 🛠️ **Tool Selection**
+1. Parse tool selection (default: gemini)
+2. If `--enhance`: Execute `/enhance-prompt` first
+3. Assemble context (files + CLAUDE.md)
+4. Execute CLI tool
+5. Optional: Save to session
 
-| Tool | Best For | Wrapper |
+## Enhancement Integration
-|------|----------|---------|
-| **gemini** (default) | General analysis, exploration | `~/.claude/scripts/gemini-wrapper` |
-| **qwen** | Architecture, design patterns | `~/.claude/scripts/qwen-wrapper` |
-| **codex** | Development queries, deep analysis | `codex --full-auto exec` |
 
-### 🔄 **Original Execution Workflow**
+**When `--enhance` flag present**: Execute `/enhance-prompt "[inquiry]"` first, then use enhanced output (INTENT/CONTEXT/ACTION) to build the chat command.
 
-`Parse Input` **->** `[Optional] Enhance` **->** `Assemble Context` **->** `Construct Prompt` **->** `Execute Gemini CLI` **->** `(Optional) Save Session`
+## Context Assembly
 
-### 🎯 **Enhancement Integration**
+Context gathered from:
+1. **Project Guidelines**: `@{CLAUDE.md,**/*CLAUDE.md}` (always)
+2. **User-Explicit Files**: Files specified by user
+3. **All Files Flag**: `--all-files` includes entire codebase
 
-**When `--enhance` flag present**:
+## Command Template
+
+**Gemini/Qwen**:
 ```bash
-# Step 1: Enhance the inquiry
+cd [dir] && ~/.claude/scripts/[gemini|qwen]-wrapper -p "
-SlashCommand(command="/enhance-prompt \"[inquiry]\"")
+PURPOSE: [inquiry goal]
-
+TASK: [specific question]
-# Step 2: Use enhanced output for chat
+CONTEXT: @{CLAUDE.md} @{target_files}
-# Enhanced output provides enriched context and structured intent
+EXPECTED: [response format]
-```
+RULES: [constraints]
-
-**Example**:
-```bash
-# User: /gemini:chat --enhance "fix the login"
-
-# Step 1: Enhance
-/enhance-prompt "fix the login"
-# Returns:
-# INTENT: Debug login authentication failure
-# CONTEXT: JWT auth in src/auth/, session state issue
-# ACTION: Check token validation → verify middleware → test flow
-
-# Step 2: Chat with enhanced context
-gemini -p "Debug login authentication failure. Focus on JWT token validation
-in src/auth/, verify middleware integration, and test authentication flow.
-Known issue: session state management"
-```
-
-### 📚 **Context Assembly**
-
-Context is gathered from:
-1. **Project Guidelines**: Always includes `@{CLAUDE.md,**/*CLAUDE.md}`
-2. **User-Explicit Files**: Files specified by the user (e.g., `@{src/auth/*.js}`)
-3. **All Files Flag**: The `--all-files` flag includes the entire codebase
-
-### 📝 **Prompt Format**
-
-**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
-
-```bash
-cd [directory] && ~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: [clear analysis/inquiry goal]
-TASK: [specific analysis or question]
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} @{target_files}
-EXPECTED: [expected response format]
-RULES: [constraints or focus areas]
 "
+
+# With --all-files
+cd [dir] && ~/.claude/scripts/[gemini|qwen]-wrapper --all-files -p "..."
 ```
 
-### ⚙️ **Execution Implementation**
+**Codex**:
-
-**Standard Template**:
 ```bash
-cd . && ~/.claude/scripts/gemini-wrapper -p "
+codex -C [dir] --full-auto exec "
-PURPOSE: [user inquiry goal]
+PURPOSE: [inquiry goal]
-TASK: [specific question or analysis]
+TASK: [specific question]
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} @{inferred_or_specified_files}
+CONTEXT: @{CLAUDE.md} @{target_files}
-EXPECTED: Analysis with file references and code examples
+EXPECTED: [response format]
-RULES: [focus areas based on inquiry]
+RULES: [constraints]
-"
+" --skip-git-repo-check -s danger-full-access
+
+# With image attachment
+codex -C [dir] -i screenshot.png --full-auto exec "..." --skip-git-repo-check -s danger-full-access
 ```
 
-**With --all-files flag**:
+## Examples
+
 ```bash
-cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
+/cli:chat "analyze the authentication flow"              # Gemini (default)
-PURPOSE: [user inquiry goal]
+/cli:chat --tool qwen "optimize React component"         # Qwen
-TASK: [specific question or analysis]
+/cli:chat --tool codex "review security vulnerabilities" # Codex
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [entire codebase]
+/cli:chat --enhance "fix the login"                      # Enhanced prompt
-EXPECTED: Comprehensive analysis across all files
+/cli:chat --all-files "find all API endpoints"           # Full codebase
-RULES: [focus areas based on inquiry]
-"
 ```
 
-**Example - Authentication Analysis**:
+## Session Persistence
-```bash
-cd . && ~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: Understand authentication flow implementation
-TASK: Analyze authentication flow and identify patterns
-CONTEXT: @{**/*auth*,**/*login*} @{CLAUDE.md}
-EXPECTED: Flow diagram, security assessment, integration points
-RULES: Focus on security patterns and JWT handling
-"
-```
 
-**Example - Performance Optimization**:
+- **Active Session**: Save to `.workflow/WFS-[id]/.chat/chat-[timestamp].md`
-```bash
+- **No Session**: Return results directly
-cd src/components && ~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: Optimize React component performance
-TASK: Identify performance bottlenecks in component rendering
-CONTEXT: @{**/*.{jsx,tsx}} @{CLAUDE.md}
-EXPECTED: Specific optimization recommendations with file:line references
-RULES: Focus on re-render patterns and memoization opportunities
-"
-```
-
-### 💾 **Session Persistence**
-
-When `--save-session` flag is used:
--   Check for existing active session (`.workflow/.active-*` markers)
--   Save to existing session's `.chat/` directory or create new session
--   File format: `chat-YYYYMMDD-HHMMSS.md`
--   Include query, context, and response in saved file
-
-**Session Template:**
-```markdown
-# Chat Session: [Timestamp]
-
-## Query
-[Original user inquiry]
-
-## Context
-[Files and patterns included in analysis]
-
-## Gemini Response
-[Complete response from Gemini CLI]
-```

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

@@ -0,0 +1,309 @@
+---
+name: codex-execute
+description: Automated task decomposition and execution with Codex using resume mechanism
+usage: /cli:codex-execute [--verify-git] <task-description|task-id>
+argument-hint: "[--verify-git] task description or task-id"
+examples:
+  - /cli:codex-execute "implement user authentication system"
+  - /cli:codex-execute --verify-git "refactor API layer"
+  - /cli:codex-execute IMPL-001
+allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
+---
+
+# CLI Codex Execute Command (/cli:codex-execute)
+
+## Purpose
+
+Automated task decomposition and sequential execution with Codex, using `codex exec "..." resume --last` mechanism for continuity between subtasks.
+
+**Input**: User description or task ID (automatically loads from `.task/[ID].json` if applicable)
+**Reference**: @~/.claude/workflows/intelligent-tools-strategy.md for Codex details
+
+## Core Workflow
+
+```
+Task Input → Decompose into Subtasks → TodoWrite Tracking →
+For Each Subtask:
+  1. Execute with Codex
+  2. [Optional] Git verification
+  3. Mark complete in TodoWrite
+  4. Resume next subtask with `codex resume --last`
+→ Final Summary
+```
+
+## Parameters
+
+- `<input>` (Required): Task description or task ID (e.g., "implement auth" or "IMPL-001")
+  - If input matches task ID format, loads from `.task/[ID].json`
+  - Otherwise, uses input as task description
+- `--verify-git` (Optional): Verify git status after each subtask completion
+
+## Execution Flow
+
+### Phase 1: Input Processing & Decomposition
+
+1. **Parse Input**:
+   - Check if input matches task ID pattern (e.g., `IMPL-001`, `TASK-123`)
+   - If yes: Load from `.task/[ID].json` and extract requirements
+   - If no: Use input as task description directly
+
+2. **Analyze & Decompose**:
+   - Analyze task complexity and scope
+   - Break down into 3-8 subtasks
+   - Create TodoWrite tracker with all subtasks
+   - Display decomposition for user review
+
+**Decomposition Criteria**:
+- Each subtask: 5-15 minutes completable
+- Clear, testable outcomes
+- Explicit dependencies
+- Focused file scope (1-5 files per subtask)
+
+### Phase 2: Sequential Execution
+
+**For First Subtask**:
+```bash
+# Initial execution (no resume needed)
+codex -C [dir] --full-auto exec "
+PURPOSE: [task goal]
+TASK: [subtask 1 description]
+CONTEXT: @{relevant_files} @{CLAUDE.md}
+EXPECTED: [specific deliverables]
+RULES: [constraints]
+Subtask 1 of N: [subtask title]
+" --skip-git-repo-check -s danger-full-access
+```
+
+**For Subsequent Subtasks** (using resume --last):
+```bash
+# Resume previous session for context continuity
+codex exec "
+CONTINUE TO NEXT SUBTASK:
+Subtask N of M: [subtask title]
+
+PURPOSE: [continuation goal]
+TASK: [subtask N description]
+CONTEXT: Previous work completed, now focus on @{new_relevant_files}
+EXPECTED: [specific deliverables]
+RULES: Build on previous subtask, maintain consistency
+" resume --last --skip-git-repo-check -s danger-full-access
+```
+
+### Phase 3: Verification (if --verify-git enabled)
+
+After each subtask completion:
+```bash
+# Check git status
+git status --short
+
+# Verify expected changes
+git diff --stat
+
+# Optional: Check for untracked files that should be committed
+git ls-files --others --exclude-standard
+```
+
+**Verification Checks**:
+- Files modified match subtask scope
+- No unexpected changes in unrelated files
+- No merge conflicts or errors
+- Code compiles/runs (if applicable)
+
+### Phase 4: TodoWrite Tracking
+
+**Initial Setup**:
+```javascript
+TodoWrite({
+  todos: [
+    { content: "Subtask 1: [description]", status: "in_progress", activeForm: "Executing subtask 1" },
+    { content: "Subtask 2: [description]", status: "pending", activeForm: "Executing subtask 2" },
+    { content: "Subtask 3: [description]", status: "pending", activeForm: "Executing subtask 3" },
+    // ... more subtasks
+    { content: "Final verification and summary", status: "pending", activeForm: "Verifying and summarizing" }
+  ]
+})
+```
+
+**After Each Subtask**:
+```javascript
+TodoWrite({
+  todos: [
+    { content: "Subtask 1: [description]", status: "completed", activeForm: "Executing subtask 1" },
+    { content: "Subtask 2: [description]", status: "in_progress", activeForm: "Executing subtask 2" },
+    // ... update status
+  ]
+})
+```
+
+## Codex Resume Mechanism
+
+**Why `codex resume --last`?**
+- Maintains conversation context across subtasks
+- Codex remembers previous decisions and patterns
+- Reduces context repetition
+- Ensures consistency in implementation style
+
+**How It Works**:
+1. First subtask creates new Codex session
+2. After completion, session is saved
+3. Subsequent subtasks use `codex resume --last` to continue
+4. Each subtask builds on previous context
+5. Final subtask completes full task
+
+**Image Support**:
+```bash
+# First subtask with design reference
+codex -C [dir] -i design.png --full-auto exec "..." --skip-git-repo-check -s danger-full-access
+
+# Resume for next subtask (image context preserved)
+codex exec "CONTINUE TO NEXT SUBTASK: ..." resume --last --skip-git-repo-check -s danger-full-access
+```
+
+## Error Handling
+
+**Subtask Failure**:
+1. Mark subtask as blocked in TodoWrite
+2. Report error details to user
+3. Pause execution for manual intervention
+4. User can choose to:
+   - Retry current subtask
+   - Continue to next subtask
+   - Abort entire task
+
+**Git Verification Failure** (if --verify-git):
+1. Show unexpected changes
+2. Pause execution
+3. Request user decision:
+   - Continue anyway
+   - Rollback and retry
+   - Manual fix
+
+**Codex Session Lost**:
+1. Detect if `codex exec "..." resume --last` fails
+2. Attempt retry with fresh session
+3. Report to user if manual intervention needed
+
+## Output Format
+
+**During Execution**:
+```
+📋 Task Decomposition:
+  1. [Subtask 1 description]
+  2. [Subtask 2 description]
+  ...
+
+▶️  Executing Subtask 1/N: [title]
+  Codex session started...
+  [Codex output]
+  ✅ Subtask 1 completed
+
+🔍 Git Verification:
+  M  src/file1.ts
+  A  src/file2.ts
+  ✅ Changes verified
+
+▶️  Executing Subtask 2/N: [title]
+  Resuming Codex session...
+  [Codex output]
+  ✅ Subtask 2 completed
+...
+
+✅ All Subtasks Completed
+📊 Summary: [file references, changes, next steps]
+```
+
+**Final Summary**:
+```markdown
+# Task Execution Summary: [Task Description]
+
+## Subtasks Completed
+1. ✅ [Subtask 1]: [files modified]
+2. ✅ [Subtask 2]: [files modified]
+...
+
+## Files Modified
+- src/file1.ts:10-50 - [changes]
+- src/file2.ts - [changes]
+
+## Git Status
+- N files modified
+- M files added
+- No conflicts
+
+## Next Steps
+- [Suggested follow-up actions]
+```
+
+## Examples
+
+**Example 1: Simple Task**
+```bash
+/cli:codex-execute "implement user authentication system"
+
+# Decomposes into:
+# 1. Create user model and database schema
+# 2. Implement JWT token generation
+# 3. Create authentication middleware
+# 4. Add login/logout endpoints
+# 5. Write tests for auth flow
+```
+
+**Example 2: With Git Verification**
+```bash
+/cli:codex-execute --verify-git "refactor API layer to use dependency injection"
+
+# After each subtask, verifies:
+# - Only expected files modified
+# - No breaking changes in unrelated code
+# - Tests still pass
+```
+
+**Example 3: With Task ID**
+```bash
+/cli:codex-execute IMPL-001
+
+# Loads task from .task/IMPL-001.json
+# Decomposes based on task requirements
+```
+
+## Best Practices
+
+1. **Subtask Granularity**: Keep subtasks small and focused
+2. **Clear Boundaries**: Each subtask should have well-defined input/output
+3. **Git Hygiene**: Use `--verify-git` for critical refactoring
+4. **Context Continuity**: Let `codex resume --last` maintain context
+5. **Recovery Points**: TodoWrite provides clear progress tracking
+6. **Image References**: Attach design files for UI tasks
+
+## Input Processing
+
+**Automatic Detection**:
+- Input matches task ID pattern → Load from `.task/[ID].json`
+- Otherwise → Use as task description
+
+**Task JSON Structure** (when loading from file):
+```json
+{
+  "task_id": "IMPL-001",
+  "title": "Implement user authentication",
+  "description": "Create JWT-based auth system",
+  "acceptance_criteria": [...],
+  "scope": {...},
+  "brainstorming_refs": [...]
+}
+```
+
+**Save Results**:
+- Execution log: `.chat/codex-execute-[timestamp].md` (if workflow active)
+- Summary: `.summaries/[TASK-ID]-summary.md` (if task ID provided)
+- TodoWrite tracking embedded in session
+
+## Notes
+
+**vs. `/cli:execute`**:
+- `/cli:execute`: Single-shot execution with Gemini/Qwen/Codex
+- `/cli:codex-execute`: Multi-stage Codex execution with automatic task decomposition and resume mechanism
+
+**Input Flexibility**: Accepts both freeform descriptions and task IDs (auto-detects and loads JSON)
+
+**Context Window**: `codex exec "..." resume --last` maintains conversation history, ensuring consistency across subtasks without redundant context injection.

.claude/commands/cli/execute.md

@@ -14,222 +14,98 @@ model: sonnet
 
 # CLI Execute Command (/cli:execute)
 
-## Overview
+## Purpose
 
-**⚡ YOLO-enabled execution**: Auto-approves all confirmations for streamlined implementation workflow.
+Execute implementation tasks with YOLO permissions (auto-approves all confirmations).
-
-**Purpose**: Execute implementation tasks using intelligent context inference and CLI tools with full permissions.
 
 **Supported Tools**: codex, gemini (default), qwen
+**Reference**: @~/.claude/workflows/intelligent-tools-strategy.md for complete tool details
 
-**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
+## YOLO Permissions
 
-## 🚨 YOLO Permissions
+Auto-approves: file pattern inference, execution, file modifications, summary generation
 
-**All confirmations auto-approved by default:**
+## Enhancement Integration
-- ✅ File pattern inference confirmation
-- ✅ Gemini execution confirmation
-- ✅ File modification confirmation
-- ✅ Implementation summary generation
 
-## 🎯 Enhancement Integration
+**When `--enhance` flag present** (Description Mode only): Execute `/enhance-prompt "[description]"` first, then use enhanced output (INTENT/CONTEXT/ACTION) for execution.
 
-**When `--enhance` flag present** (for Description Mode only):
+**Note**: Task ID Mode uses task JSON directly (no enhancement).
-```bash
-# Step 1: Enhance the description
-SlashCommand(command="/enhance-prompt \"[description]\"")
-
-# Step 2: Use enhanced output for execution
-# Enhanced output provides:
-# - INTENT: Clear technical goal
-# - CONTEXT: Session memory + codebase patterns
-# - ACTION: Specific implementation steps
-# - ATTENTION: Critical constraints
-```
-
-**Example**:
-```bash
-# User: /gemini:execute --enhance "fix login"
-
-# Step 1: Enhance
-/enhance-prompt "fix login"
-# Returns:
-# INTENT: Debug authentication failure in login flow
-# CONTEXT: JWT auth in src/auth/, known token expiry issue
-# ACTION: Fix token validation → update refresh logic → test flow
-# ATTENTION: Preserve existing session management
-
-# Step 2: Execute with enhanced context
-gemini --all-files -p "@{src/auth/**/*} @{CLAUDE.md}
-Implementation: Debug authentication failure in login flow
-Focus: Token validation, refresh logic, test flow
-Constraints: Preserve existing session management"
-```
-
-**Note**: `--enhance` only applies to Description Mode. Task ID Mode uses task JSON directly.
 
 ## Execution Modes
 
-### 1. Description Mode (supports --enhance)
+**1. Description Mode** (supports `--enhance`):
-**Input**: Natural language description
+- Input: Natural language description
-```bash
+- Process: [Optional: Enhance] → Keyword analysis → Pattern inference → Execute
-/gemini:execute "implement JWT authentication with middleware"
-/gemini:execute --enhance "implement JWT authentication with middleware"
-```
-**Process**: [Optional: Enhance] → Keyword analysis → Pattern inference → Context collection → Execution
 
-### 2. Task ID Mode (no --enhance)
+**2. Task ID Mode** (no `--enhance`):
-**Input**: Workflow task identifier
+- Input: Workflow task identifier (e.g., `IMPL-001`)
-```bash
+- Process: Task JSON parsing → Scope analysis → Execute
-/gemini:execute IMPL-001
-```
-**Process**: Task JSON parsing → Scope analysis → Context integration → Execution
 
-## Context Inference Logic
+## Context Inference
 
-**Auto-selects relevant files based on:**
+Auto-selects files based on:
 - **Keywords**: "auth" → `@{**/*auth*,**/*user*}`
 - **Technology**: "React" → `@{src/**/*.{jsx,tsx}}`
 - **Task Type**: "api" → `@{**/api/**/*,**/routes/**/*}`
-- **Always includes**: `@{CLAUDE.md,**/*CLAUDE.md}`
+- **Always**: `@{CLAUDE.md,**/*CLAUDE.md}`
 
-## Command Options
+## Options
 
-| Option | Purpose |
+- `--debug`: Verbose logging
-|--------|---------|
+- `--save-session`: Save execution to workflow session
-| `--debug` | Verbose execution logging |
-| `--save-session` | Save complete execution session to workflow |
 
 ## Workflow Integration
 
-### Session Management
+**Session Management**: Auto-detects `.workflow/.active-*` marker
-⚠️ **Auto-detects active session**: Checks `.workflow/.active-*` marker file
+- **Active**: Save to `.workflow/WFS-[id]/.chat/execute-[timestamp].md`
+- **None**: Create new session
 
-**Session storage:**
+**Task Integration**: Load from `.task/[TASK-ID].json`, update status, generate summary
-- **Active session exists**: Saves to `.workflow/WFS-[topic]/.chat/execute-[timestamp].md`
-- **No active session**: Creates new session directory
 
-### Task Integration
+## Command Template
+
+**Gemini/Qwen** (with YOLO approval):
 ```bash
-# Execute specific workflow task
+cd [dir] && ~/.claude/scripts/[gemini|qwen]-wrapper --approval-mode yolo -p "
-/gemini:execute IMPL-001
+PURPOSE: [implementation goal]
-
+TASK: [specific task]
-# Loads from: .task/IMPL-001.json
+MODE: write
-# Uses: task context, brainstorming refs, scope definitions
+CONTEXT: @{inferred_patterns} @{CLAUDE.md}
-# Updates: workflow status, generates summary
+EXPECTED: Implementation with file:line references
-```
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/[category]/[template].txt) | [constraints]
-
-## Execution Templates
-
-**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
-
-### Permission Requirements
-
-**Gemini Write Access** (when file modifications needed):
-- Add `--approval-mode yolo` flag for auto-approval
-- Required for: file creation, modification, deletion
-
-### User Description Template
-```bash
-cd [target-directory] && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
-PURPOSE: [clear implementation goal from description]
-TASK: [specific implementation task]
-CONTEXT: @{inferred_patterns} @{CLAUDE.md,**/*CLAUDE.md}
-EXPECTED: Implementation code with file:line locations, test cases, integration guidance
-RULES: [template reference if applicable] | [constraints]
 "
 ```
 
-**Example**:
+**Codex**:
 ```bash
-cd . && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
+codex -C [dir] --full-auto exec "
-PURPOSE: Implement JWT authentication with middleware
+PURPOSE: [implementation goal]
-TASK: Create authentication system with token validation
+TASK: [specific task]
-CONTEXT: @{**/*auth*,**/*middleware*} @{CLAUDE.md}
+MODE: auto
-EXPECTED: Auth service, middleware, tests with file modifications
+CONTEXT: @{inferred_patterns} @{CLAUDE.md}
-RULES: Follow existing auth patterns | Security best practices
+EXPECTED: Implementation with file:line references
-"
+RULES: [constraints]
+" --skip-git-repo-check -s danger-full-access
+
+# With image attachment
+codex -C [dir] -i design.png --full-auto exec "..." --skip-git-repo-check -s danger-full-access
 ```
 
-### Task ID Template
+## Examples
-```bash
-cd [task-directory] && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
-PURPOSE: [task_title]
-TASK: Execute [task-id] implementation
-CONTEXT: @{task_files} @{brainstorming_refs} @{CLAUDE.md,**/*CLAUDE.md}
-EXPECTED: Complete implementation following acceptance criteria
-RULES: $(cat [task_template]) | Task type: [task_type], Scope: [task_scope]
-"
-```
 
-**Example**:
 ```bash
-cd .workflow/WFS-123 && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
+/cli:execute "implement JWT authentication with middleware"  # Description mode
-PURPOSE: Implement user profile editing
+/cli:execute --enhance "implement JWT authentication"        # Enhanced
-TASK: Execute IMPL-001 implementation
+/cli:execute IMPL-001                                        # Task ID mode
-CONTEXT: @{src/user/**/*} @{.brainstorming/product-owner/analysis.md} @{CLAUDE.md}
+/cli:execute --tool codex "optimize database queries"        # Codex execution
-EXPECTED: Profile edit API, UI components, validation, tests
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/development/feature.txt) | Type: feature, Scope: user module
-"
 ```
 
 ## Auto-Generated Outputs
 
-### 1. Implementation Summary
+- **Summary**: `.summaries/[TASK-ID]-summary.md`
-**Location**: `.summaries/[TASK-ID]-summary.md` or auto-generated ID
+- **Session**: `.chat/execute-[timestamp].md`
 
-```markdown
+## Notes
-# Task Summary: [Task-ID] [Description]
 
-## Implementation
+**vs. `/cli:analyze`**: Execute performs implementation, analyze is read-only.
-- **Files Modified**: [file:line references]
-- **Features Added**: [specific functionality]
-- **Context Used**: [inferred patterns]
-
-## Integration
-- [Links to workflow documents]
-```
-
-### 2. Execution Session
-**Location**: `.chat/execute-[timestamp].md`
-
-```markdown
-# Execution Session: [Timestamp]
-
-## Input
-[User description or Task ID]
-
-## Context Inference
-[File patterns used with rationale]
-
-## Implementation Results
-[Generated code and modifications]
-
-## Status Updates
-[Workflow integration updates]
-```
-
-## Error Handling
-
-- **Task ID not found**: Lists available tasks
-- **Pattern inference failure**: Uses generic `src/**/*` pattern
-- **Execution failure**: Attempts fallback with simplified context
-- **File modification errors**: Reports specific file/permission issues
-
-## Performance Features
-
-- **Smart caching**: Frequently used pattern mappings
-- **Progressive inference**: Precise → broad pattern fallback
-- **Parallel execution**: When multiple contexts needed
-- **Directory optimization**: Switches to optimal execution path
-
-## Integration Workflow
-
-**Typical sequence:**
-1. `workflow:plan` → Creates tasks
-2. `/gemini:execute IMPL-001` → Executes with YOLO permissions
-3. Auto-updates workflow status and generates summaries
-4. `workflow:review` → Final validation
-
-**vs. `/gemini:analyze`**: Execute performs analysis **and implementation**, analyze is read-only.
 

.claude/commands/version.md

@@ -0,0 +1,261 @@
+---
+name: version
+description: Display version information and check for updates
+usage: /version
+examples:
+  - /version
+allowed-tools: Bash(*)
+---
+
+# Version Command (/version)
+
+## Purpose
+Display local and global installation versions, check for the latest updates from GitHub, and provide upgrade recommendations.
+
+## Execution Flow
+1. **Local Version Check**: Read version information from `./.claude/version.json` if it exists.
+2. **Global Version Check**: Read version information from `~/.claude/version.json` if it exists.
+3. **Fetch Remote Versions**: Use GitHub API to get the latest stable release tag and the latest commit hash from the main branch.
+4. **Compare & Suggest**: Compare installed versions with the latest remote versions and provide upgrade suggestions if applicable.
+
+## Step 1: Check Local Version
+
+### Check if local version.json exists
+```bash
+bash(test -f ./.claude/version.json && echo "found" || echo "not_found")
+```
+
+### Read local version (if exists)
+```bash
+bash(cat ./.claude/version.json)
+```
+
+### Extract version with jq (preferred)
+```bash
+bash(cat ./.claude/version.json | grep -o '"version": *"[^"]*"' | cut -d'"' -f4)
+```
+
+### Extract installation date
+```bash
+bash(cat ./.claude/version.json | grep -o '"installation_date_utc": *"[^"]*"' | cut -d'"' -f4)
+```
+
+**Output Format**:
+```
+Local Version: 3.2.1
+Installed: 2025-10-03T12:00:00Z
+```
+
+## Step 2: Check Global Version
+
+### Check if global version.json exists
+```bash
+bash(test -f ~/.claude/version.json && echo "found" || echo "not_found")
+```
+
+### Read global version
+```bash
+bash(cat ~/.claude/version.json)
+```
+
+### Extract version
+```bash
+bash(cat ~/.claude/version.json | grep -o '"version": *"[^"]*"' | cut -d'"' -f4)
+```
+
+### Extract installation date
+```bash
+bash(cat ~/.claude/version.json | grep -o '"installation_date_utc": *"[^"]*"' | cut -d'"' -f4)
+```
+
+**Output Format**:
+```
+Global Version: 3.2.1
+Installed: 2025-10-03T12:00:00Z
+```
+
+## Step 3: Fetch Latest Stable Release
+
+### Call GitHub API for latest release (with timeout)
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null, timeout: 30000)
+```
+
+### Extract tag name (version)
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"tag_name": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
+```
+
+### Extract release name
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"name": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
+```
+
+### Extract published date
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"published_at": *"[^"]*"' | cut -d'"' -f4, timeout: 30000)
+```
+
+**Output Format**:
+```
+Latest Stable: v3.2.2
+Release: v3.2.2: Independent Test-Gen Workflow with Cross-Session Context
+Published: 2025-10-03T04:10:08Z
+```
+
+## Step 4: Fetch Latest Main Branch
+
+### Call GitHub API for latest commit on main (with timeout)
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null, timeout: 30000)
+```
+
+### Extract commit SHA (short)
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep -o '"sha": *"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-7, timeout: 30000)
+```
+
+### Extract commit message (first line only)
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep '"message":' | cut -d'"' -f4 | cut -d'\' -f1, timeout: 30000)
+```
+
+### Extract commit date
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep -o '"date": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
+```
+
+**Output Format**:
+```
+Latest Dev: a03415b
+Message: feat: Add version tracking and upgrade check system
+Date: 2025-10-03T04:46:44Z
+```
+
+## Step 5: Compare Versions and Suggest Upgrade
+
+### Normalize versions (remove 'v' prefix)
+```bash
+bash(echo "v3.2.1" | sed 's/^v//')
+```
+
+### Compare two versions
+```bash
+bash(printf "%s\n%s" "3.2.1" "3.2.2" | sort -V | tail -n 1)
+```
+
+### Check if versions are equal
+```bash
+# If equal: Up to date
+# If remote newer: Upgrade available
+# If local newer: Development version
+```
+
+**Output Scenarios**:
+
+**Scenario 1: Up to date**
+```
+✅ You are on the latest stable version (3.2.1)
+```
+
+**Scenario 2: Upgrade available**
+```
+⬆️ A newer stable version is available: v3.2.2
+Your version: 3.2.1
+
+To upgrade:
+PowerShell: iex (iwr -useb https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.ps1)
+Bash: bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.sh)
+```
+
+**Scenario 3: Development version**
+```
+✨ You are running a development version (3.3.0-dev)
+This is newer than the latest stable release (v3.2.2)
+```
+
+## Simple Bash Commands
+
+### Basic Operations
+```bash
+# Check local version file
+bash(test -f ./.claude/version.json && cat ./.claude/version.json)
+
+# Check global version file
+bash(test -f ~/.claude/version.json && cat ~/.claude/version.json)
+
+# Extract version from JSON
+bash(cat version.json | grep -o '"version": *"[^"]*"' | cut -d'"' -f4)
+
+# Extract date from JSON
+bash(cat version.json | grep -o '"installation_date_utc": *"[^"]*"' | cut -d'"' -f4)
+
+# Fetch latest release (with timeout)
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null, timeout: 30000)
+
+# Extract tag name
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"tag_name": *"[^"]*"' | cut -d'"' -f4, timeout: 30000)
+
+# Extract release name
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"name": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
+
+# Fetch latest commit (with timeout)
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null, timeout: 30000)
+
+# Extract commit SHA
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep -o '"sha": *"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-7, timeout: 30000)
+
+# Extract commit message (first line)
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep '"message":' | cut -d'"' -f4 | cut -d'\' -f1, timeout: 30000)
+
+# Compare versions
+bash(printf "%s\n%s" "3.2.1" "3.2.2" | sort -V | tail -n 1)
+
+# Remove 'v' prefix
+bash(echo "v3.2.1" | sed 's/^v//')
+```
+
+## Error Handling
+
+### No installation found
+```
+WARNING: Claude Code Workflow not installed
+Install using:
+PowerShell: iex (iwr -useb https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.ps1)
+```
+
+### Network error
+```
+ERROR: Could not fetch latest version from GitHub
+Check your network connection
+```
+
+### Invalid version.json
+```
+ERROR: version.json is invalid or corrupted
+```
+
+## Design Notes
+
+- Uses simple, direct bash commands instead of complex functions
+- Each step is independent and can be executed separately
+- Fallback to grep/sed for JSON parsing (no jq dependency required)
+- Network calls use curl with error suppression and 30-second timeout
+- Version comparison uses `sort -V` for accurate semantic versioning
+- Use `/commits/main` API instead of `/branches/main` for more reliable commit info
+- Extract first line of commit message using `cut -d'\' -f1` to handle JSON escape sequences
+
+## API Endpoints
+
+### GitHub API Used
+- **Latest Release**: `https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest`
+  - Fields: `tag_name`, `name`, `published_at`
+- **Latest Commit**: `https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main`
+  - Fields: `sha`, `commit.message`, `commit.author.date`
+
+### 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/brainstorm/artifacts.md

@@ -91,10 +91,11 @@ allowed-tools: TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)
 **Document Structure**:
 ```
 .workflow/WFS-[topic]/.brainstorming/
-├── topic-framework.md          # ★ STRUCTURED FRAMEWORK DOCUMENT
+└── topic-framework.md          # ★ STRUCTURED FRAMEWORK DOCUMENT
-└── workflow-session.json               # Framework metadata and role assignments
 ```
 
+**Note**: `workflow-session.json` is located at `.workflow/WFS-[topic]/workflow-session.json` (session root), not inside `.brainstorming/`.
+
 ## Framework Template Structures
 
 ### Dynamic Role-Based Framework

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

@@ -149,7 +149,7 @@ Task(subagent_type="conceptual-planning-agent",
 
      3. **load_session_metadata**
         - Action: Load session metadata and topic description
-        - Command: bash(cat .workflow/WFS-{topic}/.brainstorming/workflow-session.json 2>/dev/null || echo '{}')
+        - Command: bash(cat .workflow/WFS-{topic}/workflow-session.json 2>/dev/null || echo '{}')
         - Output: session_metadata
 
      ### Implementation Context
@@ -162,7 +162,7 @@ Task(subagent_type="conceptual-planning-agent",
      ### Session Context
      **Workflow Directory**: .workflow/WFS-{topic}/.brainstorming/
      **Output Directory**: .workflow/WFS-{topic}/.brainstorming/{role}/
-     **Session JSON**: .workflow/WFS-{topic}/.brainstorming/workflow-session.json
+     **Session JSON**: .workflow/WFS-{topic}/workflow-session.json
 
      ### Dependencies & Context
      **Topic**: {user-provided-topic}

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

@@ -88,7 +88,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/session.json)
+   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
@@ -136,7 +136,7 @@ TodoWrite({
       activeForm: "Generating structured data-architect analysis"
     },
     {
-      content: "Update session.json with data-architect completion status",
+      content: "Update workflow-session.json with data-architect completion status",
       status: "pending",
       activeForm: "Updating session metadata"
     }

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

@@ -88,7 +88,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/session.json)
+   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
@@ -136,7 +136,7 @@ TodoWrite({
       activeForm: "Generating structured product-manager analysis"
     },
     {
-      content: "Update session.json with product-manager completion status",
+      content: "Update workflow-session.json with product-manager completion status",
       status: "pending",
       activeForm: "Updating session metadata"
     }

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

@@ -88,7 +88,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/session.json)
+   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
@@ -136,7 +136,7 @@ TodoWrite({
       activeForm: "Generating structured product-owner analysis"
     },
     {
-      content: "Update session.json with product-owner completion status",
+      content: "Update workflow-session.json with product-owner completion status",
       status: "pending",
       activeForm: "Updating session metadata"
     }

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

@@ -88,7 +88,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/session.json)
+   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
@@ -136,7 +136,7 @@ TodoWrite({
       activeForm: "Generating structured scrum-master analysis"
     },
     {
-      content: "Update session.json with scrum-master completion status",
+      content: "Update workflow-session.json with scrum-master completion status",
       status: "pending",
       activeForm: "Updating session metadata"
     }

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

@@ -88,7 +88,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/session.json)
+   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
@@ -136,7 +136,7 @@ TodoWrite({
       activeForm: "Generating structured subject-matter-expert analysis"
     },
     {
-      content: "Update session.json with subject-matter-expert completion status",
+      content: "Update workflow-session.json with subject-matter-expert completion status",
       status: "pending",
       activeForm: "Updating session metadata"
     }

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

@@ -88,7 +88,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/session.json)
+   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
@@ -136,7 +136,7 @@ TodoWrite({
       activeForm: "Generating structured ui-designer analysis"
     },
     {
-      content: "Update session.json with ui-designer completion status",
+      content: "Update workflow-session.json with ui-designer completion status",
       status: "pending",
       activeForm: "Updating session metadata"
     }

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

@@ -88,7 +88,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/session.json)
+   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
@@ -136,7 +136,7 @@ TodoWrite({
       activeForm: "Generating structured ux-expert analysis"
     },
     {
-      content: "Update session.json with ux-expert completion status",
+      content: "Update workflow-session.json with ux-expert completion status",
       status: "pending",
       activeForm: "Updating session metadata"
     }

.claude/commands/workflow/execute.md

@@ -356,8 +356,8 @@ Task(subagent_type="{meta.agent}",
 
      **WORKFLOW COMPLETION CHECK**:
      After updating task status, check if workflow is complete:
-     total_tasks=\$(ls .workflow/*/\.task/*.json | wc -l)
+     total_tasks=\$(find .workflow/*/\.task/ -name "*.json" -type f 2>/dev/null | wc -l)
-     completed_tasks=\$(ls .workflow/*/\.summaries/*.md 2>/dev/null | wc -l)
+     completed_tasks=\$(find .workflow/*/\.summaries/ -name "*.md" -type f 2>/dev/null | wc -l)
      if [ \$total_tasks -eq \$completed_tasks ]; then
        SlashCommand(command=\"/workflow:session:complete\")
      fi"),
@@ -433,7 +433,7 @@ Task(subagent_type="{meta.agent}",
       "task_description": "Implement following consolidated synthesis specification...",
       "modification_points": ["Apply synthesis specification requirements..."]
     },
-    "target_files": ["file:function:lines"]
+    "target_files": ["file:function:lines", "path/to/NewFile.ts"]
   }
 }
 ```

.claude/commands/workflow/plan.md

@@ -15,13 +15,22 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Execute 4 slash commands in sequence, parse their outputs, pass context between them, and ensure complete execution.
+**This command is a pure orchestrator**: Execute 4 slash commands in sequence, parse their outputs, pass context between them, and ensure complete execution through **automatic continuation**.
 
-**Execution Flow**:
+**Execution Model - Auto-Continue Workflow**:
-1. Initialize TodoWrite → Execute Phase 1 → Parse output → Update TodoWrite
+
-2. Execute Phase 2 with Phase 1 data → Parse output → Update TodoWrite
+Each phase executes and returns to user, then **automatically continues** to next phase:
-3. Execute Phase 3 with Phase 2 data → Parse output → Update TodoWrite
+
-4. Execute Phase 4 with Phase 3 validation → Update TodoWrite → Return summary
+1. **User triggers**: `/workflow:plan "task"`
+2. **Phase 1 executes** → Returns to user with results
+3. **Auto-continue to Phase 2** → Returns to user with results
+4. **Auto-continue to Phase 3** → Returns to user with results
+5. **Auto-continue to Phase 4** → Returns final summary
+
+**Auto-Continue Mechanism**:
+- Read TodoList to determine current phase status
+- Execute next pending phase based on TodoList state
+- No external state files needed - TodoList tracks progress
 
 **Execution Modes**:
 - **Manual Mode** (default): Use `/workflow:tools:task-generate`
@@ -32,9 +41,8 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 command execution
 2. **No Preliminary Analysis**: Do not read files, analyze structure, or gather context before Phase 1
 3. **Parse Every Output**: Extract required data from each command's output for next phase
-4. **Sequential Execution**: Each phase depends on previous phase's output
+4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
-5. **Complete All Phases**: Do not return to user until Phase 4 completes
+5. **Track Progress**: Update TodoWrite after every phase completion
-6. **Track Progress**: Update TodoWrite after every phase completion
 
 ## 4-Phase Execution
 
@@ -64,6 +72,8 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 **TodoWrite**: Mark phase 1 completed, phase 2 in_progress
 
+**After Phase 1**: Return to user showing Phase 1 results, then auto-continue to Phase 2
+
 ---
 
 ### Phase 2: Context Gathering
@@ -83,6 +93,8 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 **TodoWrite**: Mark phase 2 completed, phase 3 in_progress
 
+**After Phase 2**: Return to user showing Phase 2 results, then auto-continue to Phase 3
+
 ---
 
 ### Phase 3: Intelligent Analysis
@@ -99,6 +111,8 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 **TodoWrite**: Mark phase 3 completed, phase 4 in_progress
 
+**After Phase 3**: Return to user showing Phase 3 results, then auto-continue to Phase 4
+
 ---
 
 ### Phase 4: Task Generation
@@ -227,23 +241,23 @@ Return summary to user
 
 - **Parsing Failure**: If output parsing fails, retry command once, then report error
 - **Validation Failure**: If validation fails, report which file/data is missing
-- **Command Failure**: Keep phase `in_progress`, report error to user, do not proceed
+- **Command Failure**: Keep phase `in_progress`, report error to user, do not proceed to next phase
 
 ## Coordinator Checklist
 
 ✅ **Pre-Phase**: Convert user input to structured format (GOAL/SCOPE/CONTEXT)
 ✅ Initialize TodoWrite before any command
 ✅ Execute Phase 1 immediately with structured description
-✅ Parse session ID from Phase 1 output
+✅ 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
+✅ Parse context path from Phase 2 output, store in memory
 ✅ Pass session ID and context path to Phase 3 command
 ✅ Verify ANALYSIS_RESULTS.md after Phase 3
 ✅ Select correct Phase 4 command based on --agent flag
 ✅ Pass session ID to Phase 4 command
 ✅ Verify all Phase 4 outputs
 ✅ Update TodoWrite after each phase
-✅ Return summary only after Phase 4 completes
+✅ After each phase, automatically continue to next phase based on TodoList status
 
 ## Structure Template Reference
 

.claude/commands/workflow/review.md

@@ -55,7 +55,7 @@ if [ ! -d ".workflow/${sessionId}" ]; then
 fi
 
 # Check for completed tasks
-if [ ! -d ".workflow/${sessionId}/.summaries" ] || [ -z "$(ls .workflow/${sessionId}/.summaries/IMPL-*.md 2>/dev/null)" ]; then
+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"
     exit 1
 fi

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

@@ -44,8 +44,8 @@ mv temp.json .workflow/WFS-session/workflow-session.json
 
 ### Step 5: Count Final Statistics
 ```bash
-ls .workflow/WFS-session/.task/*.json 2>/dev/null | wc -l
+find .workflow/WFS-session/.task/ -name "*.json" -type f 2>/dev/null | wc -l
-ls .workflow/WFS-session/.summaries/*.md 2>/dev/null | wc -l
+find .workflow/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
 ```
 
 ### Step 6: Remove Active Marker
@@ -56,12 +56,12 @@ rm .workflow/.active-WFS-session-name
 ## Simple Bash Commands
 
 ### Basic Operations
-- **Find active session**: `ls .workflow/.active-*`
+- **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**: `ls .task/*.json | wc -l`
+- **Count tasks**: `find .task/ -name "*.json" -type f | wc -l`
-- **Count completed**: `ls .summaries/*.md | wc -l`
+- **Count completed**: `find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l`
 - **Remove marker**: `rm .workflow/.active-session`
 
 ### Completion Result
@@ -92,11 +92,11 @@ Session Completion Summary:
 ### Error Handling
 ```bash
 # No active session
-ls .workflow/.active-* 2>/dev/null || echo "No active session found"
+find .workflow/ -name ".active-*" -type f 2>/dev/null || echo "No active session found"
 
 # Incomplete tasks
-task_count=$(ls .task/*.json | wc -l)
+task_count=$(find .task/ -name "*.json" -type f | wc -l)
-summary_count=$(ls .summaries/*.md 2>/dev/null | 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"
 ```
 

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

@@ -35,8 +35,8 @@ jq -r '.session_id, .status, .project' .workflow/WFS-session/workflow-session.js
 
 ### Step 4: Count Task Progress
 ```bash
-ls .workflow/WFS-session/.task/*.json 2>/dev/null | wc -l
+find .workflow/WFS-session/.task/ -name "*.json" -type f 2>/dev/null | wc -l
-ls .workflow/WFS-session/.summaries/*.md 2>/dev/null | wc -l
+find .workflow/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
 ```
 
 ### Step 5: Get Creation Time
@@ -47,11 +47,11 @@ jq -r '.created_at // "unknown"' .workflow/WFS-session/workflow-session.json
 ## Simple Bash Commands
 
 ### Basic Operations
-- **List sessions**: `ls .workflow/WFS-*`
+- **List sessions**: `find .workflow/ -maxdepth 1 -type d -name "WFS-*"`
-- **Find active**: `ls .workflow/.active-*`
+- **Find active**: `find .workflow/ -name ".active-*" -type f`
 - **Read session data**: `jq -r '.session_id, .status' session.json`
-- **Count tasks**: `ls .task/*.json | wc -l`
+- **Count tasks**: `find .task/ -name "*.json" -type f | wc -l`
-- **Count completed**: `ls .summaries/*.md | wc -l`
+- **Count completed**: `find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l`
 - **Get timestamp**: `jq -r '.created_at' session.json`
 
 ## Simple Output Format

.claude/commands/workflow/status.md

@@ -25,7 +25,7 @@ Generates on-demand views from JSON task data. No synchronization needed - all v
 
 ### Step 1: Find Active Session
 ```bash
-ls .workflow/.active-* 2>/dev/null | head -1
+find .workflow/ -name ".active-*" -type f 2>/dev/null | head -1
 ```
 
 ### Step 2: Load Session Data
@@ -35,7 +35,7 @@ cat .workflow/WFS-session/workflow-session.json
 
 ### Step 3: Scan Task Files
 ```bash
-ls .workflow/WFS-session/.task/*.json 2>/dev/null
+find .workflow/WFS-session/.task/ -name "*.json" -type f 2>/dev/null
 ```
 
 ### Step 4: Generate Task Status
@@ -45,8 +45,8 @@ cat .workflow/WFS-session/.task/impl-1.json | jq -r '.status'
 
 ### Step 5: Count Task Progress
 ```bash
-ls .workflow/WFS-session/.task/*.json | wc -l
+find .workflow/WFS-session/.task/ -name "*.json" -type f | wc -l
-ls .workflow/WFS-session/.summaries/*.md 2>/dev/null | wc -l
+find .workflow/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
 ```
 
 ### Step 6: Display Overview
@@ -66,11 +66,11 @@ ls .workflow/WFS-session/.summaries/*.md 2>/dev/null | wc -l
 ## Simple Bash Commands
 
 ### Basic Operations
-- **Find active session**: `ls .workflow/.active-*`
+- **Find active session**: `find .workflow/ -name ".active-*" -type f`
 - **Read session info**: `cat .workflow/session/workflow-session.json`
-- **List tasks**: `ls .workflow/session/.task/*.json`
+- **List tasks**: `find .workflow/session/.task/ -name "*.json" -type f`
 - **Check task status**: `cat task.json | jq -r '.status'`
-- **Count completed**: `ls .summaries/*.md | wc -l`
+- **Count completed**: `find .summaries/ -name "*.md" -type f | wc -l`
 
 ### Task Status Check
 - **pending**: Not started yet
@@ -87,8 +87,8 @@ test -f .workflow/.active-* && echo "Session active"
 for f in .workflow/session/.task/*.json; do jq empty "$f" && echo "Valid: $f"; done
 
 # Check summaries match
-ls .task/*.json | wc -l
+find .task/ -name "*.json" -type f | wc -l
-ls .summaries/*.md | wc -l
+find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l
 ```
 
 ## Simple Output Format

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

@@ -1,11 +1,11 @@
 ---
 name: test-gen
-description: Orchestrate test-fix workflow by analyzing implementation and generating TEST-FIX tasks
+description: Create independent test-fix workflow session by analyzing completed implementation
-usage: /workflow:test-gen [session-id]
+usage: /workflow:test-gen <source-session-id>
-argument-hint: "[session-id]"
+argument-hint: "<source-session-id>"
 examples:
-  - /workflow:test-gen
   - /workflow:test-gen WFS-user-auth
+  - /workflow:test-gen WFS-api-refactor
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
@@ -13,134 +13,177 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Analyze completed implementation session, generate test-fix workflow through standardized tool commands, and trigger automated test validation.
+**This command is a pure orchestrator**: Creates an independent test-fix workflow session for validating a completed implementation. It reuses the standard planning toolchain with automatic cross-session context gathering.
+
+**Core Principles**:
+- **Session Isolation**: Creates new `WFS-test-[source]` session to keep verification separate from implementation
+- **Context-First**: Prioritizes gathering code changes and summaries from source session
+- **Format Reuse**: Creates standard `IMPL-*.json` task, using `meta.type: "test-fix"` for agent assignment
+- **Parameter Simplification**: Tools auto-detect test session type via metadata, no manual cross-session parameters needed
 
 **Execution Flow**:
-1. Initialize TodoWrite → Execute Phase 1 → Parse output → Update TodoWrite
+1. Initialize TodoWrite → Create test session → Parse session ID
-2. Execute Phase 2 with Phase 1 data → Parse output → Update TodoWrite
+2. Gather cross-session context (automatic) → Parse context path
-3. Execute Phase 3 with Phase 2 data → Parse output → Update TodoWrite
+3. Analyze implementation with concept-enhanced → Parse ANALYSIS_RESULTS.md
-4. Execute Phase 4 with Phase 3 validation → Update TodoWrite → Return summary
+4. Generate test task from analysis → Return summary
 
 ## Core Rules
 
-1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 session discovery
+1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 test session creation
 2. **No Preliminary Analysis**: Do not read files or analyze before Phase 1
 3. **Parse Every Output**: Extract required data from each phase for next phase
 4. **Sequential Execution**: Each phase depends on previous phase's output
-5. **Complete All Phases**: Do not return to user until Phase 4 completes
+5. **Complete All Phases**: Do not return to user until Phase 4 completes (execution triggered separately)
 6. **Track Progress**: Update TodoWrite after every phase completion
-7. **Use Standard Tools**: Follow plan.md pattern using context-gather, concept-enhanced, task-generate
+7. **Automatic Detection**: context-gather auto-detects test session and gathers source session context
 
 ## 4-Phase Execution
 
-### Phase 1: Session Discovery & Context Gathering
+### Phase 1: Create Test Session
-**Command**: `SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"TEST-FIX: Validate implementation for [sessionId]\"")`
+**Command**: `SlashCommand(command="/workflow:session:start --new \"Test validation for [sourceSessionId]\"")`
 
-**Session ID Resolution**:
+**Input**: `sourceSessionId` from user argument (e.g., `WFS-user-auth`)
-- If argument provided → Use directly as `sessionId`
-- If no argument → Auto-detect from `.workflow/.active-*` marker
-- Format: `WFS-[session-name]`
 
-**Task Description Structure**:
+**Expected Behavior**:
-```
+- Creates new session with pattern `WFS-test-[source-slug]` (e.g., `WFS-test-user-auth`)
-GOAL: Execute and validate all tests for completed implementation
+- Writes metadata to `workflow-session.json`:
-SCOPE: Test execution, failure diagnosis, code fixing
+  - `workflow_type: "test_session"`
-CONTEXT: Implementation session [sessionId] with completed IMPL tasks
+  - `source_session_id: "[sourceSessionId]"`
-```
+- Returns new session ID for subsequent phases
 
 **Parse Output**:
-- Extract: context package path (store as `contextPath`)
+- Extract: new test session ID (store as `testSessionId`)
-- Typical pattern: `.workflow/[sessionId]/.process/context-package-test.json`
+- Pattern: `WFS-test-[slug]`
 
 **Validation**:
-- Session directory `.workflow/[sessionId]/` exists
+- Source session `.workflow/[sourceSessionId]/` exists
-- Session has completed IMPL tasks (check .summaries/IMPL-*-summary.md)
+- Source session has completed IMPL tasks (`.summaries/IMPL-*-summary.md`)
-- Context package created successfully
+- New test session directory created
+- Metadata includes `workflow_type` and `source_session_id`
 
 **TodoWrite**: Mark phase 1 completed, phase 2 in_progress
 
 ---
 
-### Phase 2: Implementation Analysis
+### Phase 2: Gather Cross-Session Context
-**Command**: `SlashCommand(command="/workflow:tools:concept-enhanced --session [sessionId] --context [contextPath]")`
+**Command**: `SlashCommand(command="/workflow:tools:context-gather --session [testSessionId]")`
 
-**Input**: `sessionId` from Phase 1, `contextPath` from Phase 1
+**Input**: `testSessionId` from Phase 1 (e.g., `WFS-test-user-auth`)
 
-**Expected Analysis**:
+**Automatic Detection**:
-- Review completed implementation summaries
+- context-gather reads `.workflow/[testSessionId]/workflow-session.json`
-- Identify test files and coverage gaps
+- Detects `workflow_type: "test_session"`
-- Assess test execution strategy
+- Automatically uses `source_session_id` to gather source session context
-- Determine failure diagnosis approach
+- No need for manual `--source-session` parameter
+
+**Cross-Session Context Collection** (Automatic):
+- Implementation summaries: `.workflow/[sourceSessionId]/.summaries/IMPL-*-summary.md`
+- Code changes: `git log --since=[source_session_created_at]` for changed files
+- Original plan: `.workflow/[sourceSessionId]/IMPL_PLAN.md`
+- Test files: Discovered via MCP code-index tools
 
 **Parse Output**:
-- Verify `.workflow/[sessionId]/.process/ANALYSIS_RESULTS.md` created
+- Extract: context package path (store as `contextPath`)
-- Extract test execution recommendations
+- Pattern: `.workflow/[testSessionId]/.process/context-package.json`
-- Identify critical test areas
 
 **Validation**:
-- File `.workflow/[sessionId]/.process/ANALYSIS_RESULTS.md` exists
+- Context package created in test session directory
-- Contains test strategy and execution plan
+- Contains source session artifacts (summaries, changed files)
-- Lists focus test paths and acceptance criteria
+- Includes test file inventory
 
 **TodoWrite**: Mark phase 2 completed, phase 3 in_progress
 
 ---
 
-### Phase 3: TEST-FIX Task Generation
+### Phase 3: Implementation Analysis
-**Command**: `SlashCommand(command="/workflow:tools:task-generate --session [sessionId]")`
+**Command**: `SlashCommand(command="/workflow:tools:concept-enhanced --session [testSessionId] --context [contextPath]")`
 
-**Input**: `sessionId` from Phase 1
+**Input**:
+- `testSessionId` from Phase 1 (e.g., `WFS-test-user-auth`)
+- `contextPath` from Phase 2 (e.g., `.workflow/WFS-test-user-auth/.process/context-package.json`)
+
+**Analysis Focus**:
+- Review implementation summaries from source session
+- Identify test files and coverage gaps
+- Assess test execution strategy (unit, integration, e2e)
+- Determine failure diagnosis approach
+- Recommend code quality improvements
 
 **Expected Behavior**:
-- Parse ANALYSIS_RESULTS.md for test requirements
+- Reads context-package.json with cross-session artifacts
-- Generate TEST-FIX-001.json with:
+- Executes parallel analysis (Gemini for test strategy, optional Codex for validation)
-  - `meta.type: "test-fix"`
+- Generates comprehensive test execution strategy
-  - `meta.agent: "@test-fix-agent"`
+- Identifies code modification targets for test fixes
-  - `context.requirements`: Test execution requirements
+- Provides feasibility assessment for test validation
-  - `context.focus_paths`: Test files and source files
-  - `context.acceptance`: All tests pass criteria
-  - `flow_control.pre_analysis`: Load implementation summaries
-  - `flow_control.implementation_approach`: Test execution strategy
 
 **Parse Output**:
-- Verify `.workflow/[sessionId]/.task/TEST-FIX-001.json` exists
+- Verify `.workflow/[testSessionId]/.process/ANALYSIS_RESULTS.md` created
-- Verify `.workflow/[sessionId]/IMPL_PLAN.md` updated
+- Contains test strategy and execution plan
-- Verify `.workflow/[sessionId]/TODO_LIST.md` updated
+- Lists code modification targets (format: `file:function:lines` or `file`)
+- Includes risk assessment and optimization recommendations
 
 **Validation**:
-- Task JSON has correct structure (id, meta.type="test-fix", meta.agent="@test-fix-agent")
+- File `.workflow/[testSessionId]/.process/ANALYSIS_RESULTS.md` exists
-- IMPL_PLAN.md contains test-fix strategy
+- Contains complete analysis sections:
-- TODO_LIST.md shows TEST-FIX-001 task
+  - Current State Analysis (test coverage, existing tests)
+  - Proposed Solution Design (test execution strategy)
+  - Implementation Strategy (code targets, feasibility)
+  - Solution Optimization (performance, quality)
+  - Critical Success Factors (acceptance criteria)
 
 **TodoWrite**: Mark phase 3 completed, phase 4 in_progress
 
 ---
 
-### Phase 4: Execute Test-Fix Workflow
+### Phase 4: Generate Test Task
-**Command**: `SlashCommand(command="/workflow:execute --session [sessionId]")`
+**Command**: `SlashCommand(command="/workflow:tools:task-generate --session [testSessionId]")`
 
-**Input**: `sessionId` from Phase 1
+**Input**: `testSessionId` from Phase 1
 
 **Expected Behavior**:
-- Workflow executor detects TEST-FIX-001 task
+- Reads ANALYSIS_RESULTS.md from Phase 3
-- Assigns to @test-fix-agent
+- Extracts test strategy and code modification targets
-- Agent executes tests using flow_control.pre_analysis
+- Generates `IMPL-001.json` (reusing standard format) with:
-- If failures: diagnoses and fixes code
+  - `meta.type: "test-fix"` (enables @test-fix-agent assignment)
-- Re-runs tests until all pass
+  - `meta.agent: "@test-fix-agent"`
-- Generates completion summary
+  - `context.requirements`: Test execution requirements from analysis
+  - `context.focus_paths`: Test files and source files from analysis
+  - `context.acceptance`: All tests pass criteria
+  - `flow_control.pre_analysis`: Load source session summaries
+  - `flow_control.implementation_approach`: Test execution strategy from ANALYSIS_RESULTS.md
+  - `flow_control.target_files`: Code modification targets from analysis
+
+**Parse Output**:
+- Verify `.workflow/[testSessionId]/.task/IMPL-001.json` exists
+- Verify `.workflow/[testSessionId]/IMPL_PLAN.md` created
+- Verify `.workflow/[testSessionId]/TODO_LIST.md` created
 
 **Validation**:
-- Workflow execution started successfully
+- Task JSON has `id: "IMPL-001"` and `meta.type: "test-fix"`
-- TEST-FIX-001 task status updated to "active" or "completed"
+- IMPL_PLAN.md contains test validation strategy from ANALYSIS_RESULTS.md
+- TODO_LIST.md shows IMPL-001 task
+- flow_control includes code targets and test strategy
+- Task is ready for /workflow:execute
 
 **TodoWrite**: Mark phase 4 completed
 
 **Return to User**:
 ```
-Test-fix workflow initiated for session: [sessionId]
+Independent test-fix workflow created successfully!
-- TEST-FIX-001 created and executing
+
-- @test-fix-agent validating implementation
+Source Session: [sourceSessionId]
-- Progress: /workflow:status [sessionId]
+Test Session: [testSessionId]
+Task Created: IMPL-001 (test-fix)
+
+Next Steps:
+1. Review test plan: .workflow/[testSessionId]/IMPL_PLAN.md
+2. Execute validation: /workflow:execute
+3. Monitor progress: /workflow:status
+
+The @test-fix-agent will:
+- Execute all tests
+- Diagnose any failures
+- Fix code until tests pass
 ```
 
 ---
@@ -150,72 +193,112 @@ Test-fix workflow initiated for session: [sessionId]
 ```javascript
 // Initialize (before Phase 1)
 TodoWrite({todos: [
-  {"content": "Execute context gathering for test-fix", "status": "in_progress", "activeForm": "Executing context gathering for test-fix"},
+  {"content": "Create independent test session", "status": "in_progress", "activeForm": "Creating test session"},
-  {"content": "Execute implementation analysis", "status": "pending", "activeForm": "Executing implementation analysis"},
+  {"content": "Gather cross-session context", "status": "pending", "activeForm": "Gathering cross-session context"},
-  {"content": "Execute TEST-FIX task generation", "status": "pending", "activeForm": "Executing TEST-FIX task generation"},
+  {"content": "Analyze implementation for test strategy", "status": "pending", "activeForm": "Analyzing implementation"},
-  {"content": "Execute test-fix workflow", "status": "pending", "activeForm": "Executing test-fix workflow"}
+  {"content": "Generate test validation task", "status": "pending", "activeForm": "Generating test validation task"}
 ]})
 
 // After Phase 1
 TodoWrite({todos: [
-  {"content": "Execute context gathering for test-fix", "status": "completed", "activeForm": "Executing context gathering for test-fix"},
+  {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
-  {"content": "Execute implementation analysis", "status": "in_progress", "activeForm": "Executing implementation analysis"},
+  {"content": "Gather cross-session context", "status": "in_progress", "activeForm": "Gathering cross-session context"},
-  {"content": "Execute TEST-FIX task generation", "status": "pending", "activeForm": "Executing TEST-FIX task generation"},
+  {"content": "Analyze implementation for test strategy", "status": "pending", "activeForm": "Analyzing implementation"},
-  {"content": "Execute test-fix workflow", "status": "pending", "activeForm": "Executing test-fix workflow"}
+  {"content": "Generate test validation task", "status": "pending", "activeForm": "Generating test validation task"}
 ]})
 
-// Continue pattern for Phase 2, 3, 4...
+// After Phase 2
+TodoWrite({todos: [
+  {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
+  {"content": "Gather cross-session context", "status": "completed", "activeForm": "Gathering cross-session context"},
+  {"content": "Analyze implementation for test strategy", "status": "in_progress", "activeForm": "Analyzing implementation"},
+  {"content": "Generate test validation task", "status": "pending", "activeForm": "Generating test validation task"}
+]})
+
+// After Phase 3
+TodoWrite({todos: [
+  {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
+  {"content": "Gather cross-session context", "status": "completed", "activeForm": "Gathering cross-session context"},
+  {"content": "Analyze implementation for test strategy", "status": "completed", "activeForm": "Analyzing implementation"},
+  {"content": "Generate test validation task", "status": "in_progress", "activeForm": "Generating test validation task"}
+]})
+
+// After Phase 4
+TodoWrite({todos: [
+  {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
+  {"content": "Gather cross-session context", "status": "completed", "activeForm": "Gathering cross-session context"},
+  {"content": "Analyze implementation for test strategy", "status": "completed", "activeForm": "Analyzing implementation"},
+  {"content": "Generate test validation task", "status": "completed", "activeForm": "Generating test validation task"}
+]})
 ```
 
 ## Data Flow
 
 ```
-Session ID (from argument or auto-detect)
+User: /workflow:test-gen WFS-user-auth
     ↓
-Phase 1: context-gather --session sessionId "test-fix description"
+Phase 1: session-start --new "Test validation for WFS-user-auth"
-    ↓ Output: contextPath (context-package-test.json)
+    ↓ Creates: WFS-test-user-auth session
+    ↓ Writes: workflow-session.json with workflow_type="test_session", source_session_id="WFS-user-auth"
+    ↓ Output: testSessionId = "WFS-test-user-auth"
     ↓
-Phase 2: concept-enhanced --session sessionId --context contextPath
+Phase 2: context-gather --session WFS-test-user-auth
-    ↓ Input: sessionId + contextPath
+    ↓ Auto-detects: test session type from workflow-session.json
-    ↓ Output: ANALYSIS_RESULTS.md (test execution strategy)
+    ↓ Auto-reads: source_session_id = "WFS-user-auth"
+    ↓ Gathers: Cross-session context (summaries, code changes, tests)
+    ↓ Output: .workflow/WFS-test-user-auth/.process/context-package.json
     ↓
-Phase 3: task-generate --session sessionId
+Phase 3: concept-enhanced --session WFS-test-user-auth --context context-package.json
-    ↓ Input: sessionId + ANALYSIS_RESULTS.md
+    ↓ Reads: context-package.json with cross-session artifacts
-    ↓ Output: TEST-FIX-001.json, IMPL_PLAN.md, TODO_LIST.md
+    ↓ Executes: Parallel analysis (Gemini test strategy + optional Codex validation)
+    ↓ Analyzes: Test coverage, execution strategy, code targets
+    ↓ Output: .workflow/WFS-test-user-auth/.process/ANALYSIS_RESULTS.md
     ↓
-Phase 4: execute --session sessionId
+Phase 4: task-generate --session WFS-test-user-auth
-    ↓ Input: sessionId + TEST-FIX-001.json
+    ↓ Reads: ANALYSIS_RESULTS.md with test strategy and code targets
-    ↓ Output: Test execution and fixing
+    ↓ Generates: IMPL-001.json with meta.type="test-fix"
+    ↓ Output: Task, plan, and todo files in test session
     ↓
-Return summary to user
+Return: Summary with next steps (user triggers /workflow:execute separately)
 ```
 
-## Context Gathering Customization
+## Session Metadata Design
 
-context-gather will analyze:
+**Test Session (`WFS-test-user-auth/workflow-session.json`)**:
-- Completed IMPL task summaries
+```json
-- Git changes since session start
+{
-- Test files in focus_paths
+  "session_id": "WFS-test-user-auth",
-- Implementation files to be tested
+  "project": "Test validation for user authentication implementation",
-- Test framework configuration
+  "status": "planning",
+  "created_at": "2025-10-03T12:00:00Z",
+  "workflow_type": "test_session",
+  "source_session_id": "WFS-user-auth"
+}
+```
 
-## Analysis Focus
+## Automatic Cross-Session Context Collection
 
-concept-enhanced will analyze:
+When `context-gather` detects `workflow_type: "test_session"`:
-- Test coverage gaps
+
-- Test execution strategy (unit, integration, e2e)
+**Collected from Source Session** (`.workflow/WFS-user-auth/`):
-- Failure diagnosis approaches
+- Implementation summaries: `.summaries/IMPL-*-summary.md`
-- Code fixing patterns
+- Code changes: `git log --since=[source_created_at] --name-only`
-- Test framework best practices
+- Original plan: `IMPL_PLAN.md`
+- Task definitions: `.task/IMPL-*.json`
+
+**Collected from Current Project**:
+- Test files: `mcp__code-index__find_files(pattern="*.test.*")`
+- Test configuration: `package.json`, `jest.config.js`, etc.
+- Source files: Based on changed files from git log
 
 ## Task Generation Output
 
-task-generate creates TEST-FIX-001.json with:
+task-generate creates `IMPL-001.json` (reusing standard format) with:
 
 ```json
 {
-  "id": "TEST-FIX-001",
+  "id": "IMPL-001",
-  "title": "Execute and validate tests for [sessionId]",
+  "title": "Execute and validate tests for [sourceSessionId]",
   "status": "pending",
   "meta": {
     "type": "test-fix",
@@ -239,11 +322,11 @@ task-generate creates TEST-FIX-001.json with:
   "flow_control": {
     "pre_analysis": [
       {
-        "step": "load_implementation_summaries",
+        "step": "load_source_session_summaries",
-        "action": "Load completed IMPL task summaries",
+        "action": "Load implementation summaries from source session",
         "commands": [
-          "bash(find .workflow/[sessionId]/.summaries/ -name 'IMPL-*-summary.md' 2>/dev/null)",
+          "bash(find .workflow/[sourceSessionId]/.summaries/ -name 'IMPL-*-summary.md' 2>/dev/null)",
-          "Read(.workflow/[sessionId]/.summaries/IMPL-001-summary.md)"
+          "Read(.workflow/[sourceSessionId]/.summaries/IMPL-001-summary.md)"
         ],
         "output_to": "implementation_context",
         "on_error": "skip_optional"
@@ -286,20 +369,22 @@ task-generate creates TEST-FIX-001.json with:
 ## Error Handling
 
 ### Phase 1 Failures
-- **No session found**: Return error "No active session detected. Provide session-id or run /workflow:plan first"
+- **Source session not found**: Return error "Source session [sourceSessionId] not found in .workflow/"
-- **Invalid session**: Return error "Session [sessionId] not found or incomplete"
+- **Invalid source session**: Return error "Source session [sourceSessionId] has no completed IMPL tasks"
-- **No implementation**: Return error "No completed IMPL tasks found. Complete implementation first"
+- **Session creation failed**: Return error "Could not create test session. Check /workflow:session:start"
 
 ### Phase 2 Failures
-- **Analysis failed**: Return error "Implementation analysis failed. Check context package"
+- **Context gathering failed**: Return error "Could not gather cross-session context. Check source session artifacts"
-- **No test strategy**: Return error "Could not determine test execution strategy"
+- **No source artifacts**: Return error "Source session has no implementation summaries or git history"
 
 ### Phase 3 Failures
-- **Task generation failed**: Retry once, then return error with details
+- **Analysis failed**: Return error "Implementation analysis failed. Check context package and ANALYSIS_RESULTS.md"
-- **Invalid task structure**: Return error with JSON validation details
+- **No test strategy**: Return error "Could not determine test execution strategy from analysis"
+- **Missing code targets**: Warning only, proceed with general test task
 
 ### Phase 4 Failures
-- **Execution failed**: Return error "Could not start test-fix workflow. Check session state"
+- **Task generation failed**: Retry once, then return error with details
+- **Invalid task structure**: Return error with JSON validation details
 
 ## Workflow Integration
 
@@ -307,18 +392,22 @@ task-generate creates TEST-FIX-001.json with:
 ```
 1. Implementation Phase (prior to test-gen)
    /workflow:plan "Build auth system"
+   → Creates WFS-auth session
    → @code-developer implements + writes tests
-   → Creates IMPL-001-summary.md
+   → Creates IMPL-001-summary.md in WFS-auth
 
 2. Test Generation Phase (test-gen)
    /workflow:test-gen WFS-auth
-   Phase 1: context-gather → Creates context-package-test.json
+   Phase 1: session-start → Creates WFS-test-auth session
-   Phase 2: concept-enhanced → Creates ANALYSIS_RESULTS.md
+   Phase 2: context-gather → Gathers from WFS-auth, creates context-package.json
-   Phase 3: task-generate → Creates TEST-FIX-001.json
+   Phase 3: concept-enhanced → Analyzes implementation, creates ANALYSIS_RESULTS.md
-   Phase 4: execute → Triggers @test-fix-agent
+   Phase 4: task-generate → Creates IMPL-001.json with meta.type="test-fix"
+   Returns: Summary with next steps
 
-3. Test-Fix Phase (automated)
+3. Test Execution Phase (user-triggered)
-   @test-fix-agent picks up TEST-FIX-001
+   /workflow:execute
+   → Detects active session: WFS-test-auth
+   → @test-fix-agent picks up IMPL-001 (test-fix type)
    → Runs test suite
    → Diagnoses failures (if any)
    → Fixes source code
@@ -327,39 +416,72 @@ task-generate creates TEST-FIX-001.json with:
 ```
 
 ### Output Files Created
-- `.workflow/[sessionId]/.process/context-package-test.json` - Test context package
+
-- `.workflow/[sessionId]/.process/ANALYSIS_RESULTS.md` - Test execution strategy
+**In Test Session** (`.workflow/WFS-test-auth/`):
-- `.workflow/[sessionId]/.task/TEST-FIX-001.json` - Task definition
+- `workflow-session.json` - Contains workflow_type and source_session_id
-- `.workflow/[sessionId]/IMPL_PLAN.md` - Updated with test-fix plan
+- `.process/context-package.json` - Cross-session context from WFS-auth
-- `.workflow/[sessionId]/TODO_LIST.md` - Updated with TEST-FIX task
+- `.process/ANALYSIS_RESULTS.md` - Test strategy and code targets from concept-enhanced
-- `.workflow/[sessionId]/.summaries/TEST-FIX-001-summary.md` - Created by test-fix-agent after completion
+- `.task/IMPL-001.json` - Test-fix task definition
+- `IMPL_PLAN.md` - Test validation plan (from ANALYSIS_RESULTS.md)
+- `TODO_LIST.md` - Task checklist
+- `.summaries/IMPL-001-summary.md` - Created by @test-fix-agent after completion
 
 ## Best Practices
 
-1. **Run after implementation complete**: Ensure all IMPL tasks are done before test-gen
+1. **Run after implementation complete**: Ensure source session has completed IMPL tasks and summaries
-2. **Check git commits**: Make sure implementation changes are committed
+2. **Check git commits**: Implementation changes should be committed for accurate git log analysis
-3. **Verify test files exist**: Code-developer should have created tests
+3. **Verify test files exist**: Source implementation should include test files
-4. **Monitor execution**: Use `/workflow:status` to track test-fix progress
+4. **Independent sessions**: Test session is separate from implementation session for clean separation
-5. **Review failures**: If tests fail repeatedly, check test-fix-agent summary for details
+5. **Monitor execution**: Use `/workflow:status` to track test-fix progress after /workflow:execute
 
 ## Coordinator Checklist
 
-✅ Initialize TodoWrite before any command
+✅ Initialize TodoWrite before any command (4 phases)
-✅ Execute Phase 1 immediately with session ID
+✅ Phase 1: Create test session with source session ID
-✅ Parse context package path from Phase 1 output
+✅ Parse new test session ID from Phase 1 output
-✅ Pass session ID and context path to Phase 2 command
+✅ Phase 2: Run context-gather (auto-detects test session, no extra params)
-✅ Verify ANALYSIS_RESULTS.md after Phase 2
+✅ Verify context-package.json contains cross-session artifacts
-✅ Pass session ID to Phase 3 command
+✅ Phase 3: Run concept-enhanced with session and context path
-✅ Verify all Phase 3 outputs (task JSON, IMPL_PLAN, TODO_LIST)
+✅ Verify ANALYSIS_RESULTS.md contains test strategy and code targets
-✅ Pass session ID to Phase 4 command
+✅ Phase 4: Run task-generate to create IMPL-001.json
+✅ Verify task has meta.type="test-fix" and meta.agent="@test-fix-agent"
+✅ Verify flow_control includes analysis insights and code targets
 ✅ Update TodoWrite after each phase
-✅ Return summary only after Phase 4 completes
+✅ Return summary after Phase 4 (execution is separate user action)
+
+## Required Tool Modifications
+
+### `/workflow:session:start`
+- Support `--new` flag for test session creation
+- Auto-detect test session pattern from task description
+- Write `workflow_type: "test_session"` and `source_session_id` to metadata
+
+### `/workflow:tools:context-gather`
+- Read session metadata to detect `workflow_type: "test_session"`
+- Auto-extract `source_session_id` from metadata
+- Gather cross-session context from source session artifacts
+- Include git log analysis from source session creation time
+
+### `/workflow:tools:concept-enhanced`
+- No changes required (already supports cross-session context analysis)
+- Will automatically analyze test strategy based on context-package.json
+- Generates ANALYSIS_RESULTS.md with code targets and test execution plan
+
+### `/workflow:tools:task-generate`
+- Recognize test session context and generate appropriate task
+- Create `IMPL-001.json` with `meta.type: "test-fix"`
+- Extract test strategy from ANALYSIS_RESULTS.md
+- Include code targets and cross-session references in flow_control
+
+### `/workflow:execute`
+- No changes required (already dispatches by meta.agent)
 
 ## Related Commands
 - `/workflow:plan` - Create implementation workflow (run before test-gen)
-- `/workflow:tools:context-gather` - Phase 1 tool for context collection
+- `/workflow:session:start` - Phase 1 tool for test session creation
-- `/workflow:tools:concept-enhanced` - Phase 2 tool for analysis
+- `/workflow:tools:context-gather` - Phase 2 tool for cross-session context collection
-- `/workflow:tools:task-generate` - Phase 3 tool for task creation
+- `/workflow:tools:concept-enhanced` - Phase 3 tool for implementation analysis and test strategy
-- `/workflow:execute` - Phase 4 workflow execution
+- `/workflow:tools:task-generate` - Phase 4 tool for test task creation
+- `/workflow:execute` - Execute test-fix workflow (user-triggered after test-gen)
 - `/workflow:status` - Check workflow progress
 - `@test-fix-agent` - Agent that executes and fixes tests

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

@@ -141,6 +141,9 @@ Advanced solution design and feasibility analysis engine with parallel CLI execu
      RULES:
      - Focus on SOLUTION IMPROVEMENTS and KEY DESIGN DECISIONS, NOT task planning
      - Provide architectural rationale, evaluate alternatives, assess tradeoffs
+     - **CRITICAL**: Identify code targets - existing files as "file:function:lines", new files as "file"
+     - For modifications: specify exact files/functions/line ranges
+     - For new files: specify file path only (no function or lines)
      - Do NOT create task lists, implementation steps, or code examples
      - Do NOT generate any code snippets or implementation details
      - **MUST write output to .workflow/{session_id}/.process/gemini-solution-design.md**
@@ -172,6 +175,8 @@ Advanced solution design and feasibility analysis engine with parallel CLI execu
      RULES:
      - Focus on TECHNICAL FEASIBILITY and RISK ASSESSMENT, NOT implementation planning
      - Validate architectural decisions, identify potential issues, recommend optimizations
+     - **CRITICAL**: Verify code targets - existing files "file:function:lines", new files "file"
+     - Confirm exact locations for modifications, identify additional new files if needed
      - Do NOT create task breakdowns, step-by-step guides, or code examples
      - Do NOT generate any code snippets or implementation details
      - **MUST write output to .workflow/{session_id}/.process/codex-feasibility-validation.md**
@@ -301,6 +306,39 @@ Generated ANALYSIS_RESULTS.md focuses on **solution improvements, key design dec
 - **Module Dependencies**: {dependency_graph_and_order}
 - **Quality Assurance**: {qa_approach_and_validation}
 
+### Code Modification Targets
+**Purpose**: Specific code locations for modification AND new files to create
+
+**Format**:
+- Existing files: `file:function:lines` (with line numbers)
+- New files: `file` (no function or lines)
+
+**Identified Targets**:
+1. **Target**: `src/auth/AuthService.ts:login:45-52`
+   - **Type**: Modify existing
+   - **Modification**: Enhance error handling
+   - **Rationale**: Current logic lacks validation for edge cases
+
+2. **Target**: `src/auth/PasswordReset.ts`
+   - **Type**: Create new file
+   - **Purpose**: Password reset functionality
+   - **Rationale**: New feature requirement
+
+3. **Target**: `src/middleware/auth.ts:validateToken:30-45`
+   - **Type**: Modify existing
+   - **Modification**: Add token expiry check
+   - **Rationale**: Security requirement for JWT validation
+
+4. **Target**: `tests/auth/PasswordReset.test.ts`
+   - **Type**: Create new file
+   - **Purpose**: Test coverage for password reset
+   - **Rationale**: Test requirement for new feature
+
+**Note**:
+- For new files, only specify the file path (no function or lines)
+- For existing files without line numbers, use `file:function:*` format
+- Task generation will refine these during the `analyze_task_patterns` step
+
 ### Feasibility Assessment
 - **Technical Complexity**: {complexity_rating_and_analysis}
 - **Performance Impact**: {expected_performance_characteristics}

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

@@ -212,7 +212,7 @@ Task(
         "Validate against acceptance criteria"
       ]
     },
-    "target_files": ["file:function:lines"]
+    "target_files": ["file:function:lines", "path/to/NewFile.ts"]
   }
 }
 \`\`\`

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

@@ -142,12 +142,12 @@ Generate task JSON files and IMPL_PLAN.md from analysis results with automatic a
       },
       {
         "step": "analyze_task_patterns",
-        "action": "Analyze existing code patterns",
+        "action": "Analyze existing code patterns and identify modification targets",
         "commands": [
           "bash(cd \"[focus_paths]\")",
-          "bash(~/.claude/scripts/gemini-wrapper -p \"PURPOSE: Analyze patterns TASK: Review '[title]' CONTEXT: [synthesis_specification] [individual_artifacts] EXPECTED: Pattern analysis RULES: Prioritize synthesis-specification.md\")"
+          "bash(~/.claude/scripts/gemini-wrapper -p \"PURPOSE: Identify modification targets TASK: Analyze '[title]' and locate specific files/functions/lines to modify CONTEXT: [synthesis_specification] [individual_artifacts] EXPECTED: Code locations in format 'file:function:lines' RULES: Prioritize synthesis-specification.md, identify exact modification points\")"
         ],
-        "output_to": "task_context",
+        "output_to": "task_context_with_targets",
         "on_error": "fail"
       }
     ],
@@ -175,8 +175,40 @@ Generate task JSON files and IMPL_PLAN.md from analysis results with automatic a
 1. Parse analysis results and extract task definitions
 2. Detect brainstorming artifacts with priority scoring
 3. Generate task context (requirements, focus_paths, acceptance)
-4. Build flow_control with artifact loading steps
+4. **Determine modification targets**: Extract specific code locations from analysis
-5. Create individual task JSON files in `.task/`
+5. Build flow_control with artifact loading steps and target_files
+6. Create individual task JSON files in `.task/`
+
+#### Target Files Generation (Critical)
+**Purpose**: Identify specific code locations for modification AND new files to create
+
+**Source Data Priority**:
+1. **ANALYSIS_RESULTS.md** - Should contain identified code locations
+2. **Gemini/MCP Analysis** - From `analyze_task_patterns` step
+3. **Context Package** - File references from `focus_paths`
+
+**Format**: `["file:function:lines"]` or `["file"]` (for new files)
+- `file`: Relative path from project root (e.g., `src/auth/AuthService.ts`)
+- `function`: Function/method name to modify (e.g., `login`, `validateToken`) - **omit for new files**
+- `lines`: Approximate line range (e.g., `45-52`, `120-135`) - **omit for new files**
+
+**Examples**:
+```json
+"target_files": [
+  "src/auth/AuthService.ts:login:45-52",
+  "src/middleware/auth.ts:validateToken:30-45",
+  "src/auth/PasswordReset.ts",
+  "tests/auth/PasswordReset.test.ts",
+  "tests/auth.test.ts:testLogin:15-20"
+]
+```
+
+**Generation Strategy**:
+- **New files to create** → Use `["path/to/NewFile.ts"]` (no function or lines)
+- **Existing files with specific locations** → Use `["file:function:lines"]`
+- **Existing files with function only** → Search lines using MCP/grep `["file:function:*"]`
+- **Existing files (explore entire)** → Mark as `["file.ts:*:*"]`
+- **No specific targets** → Leave empty `[]` (agent explores focus_paths)
 
 ### Phase 3: Artifact Detection & Integration
 

.claude/scripts/update_module_claude.sh

@@ -40,22 +40,22 @@ update_module_claude() {
     if [ "$module_path" = "." ]; then
         # Root directory
         layer="Layer 1 (Root)"
-        template_path="$HOME/.claude/workflows/cli-templates/prompts/dms/claude-layer1-root.txt"
+        template_path="$HOME/.claude/workflows/cli-templates/prompts/memory/claude-layer1-root.txt"
         analysis_strategy="--all-files"
     elif [[ "$clean_path" =~ ^[^/]+$ ]]; then
         # Top-level directories (e.g., .claude, src, tests)
         layer="Layer 2 (Domain)"
-        template_path="$HOME/.claude/workflows/cli-templates/prompts/dms/claude-layer2-domain.txt"
+        template_path="$HOME/.claude/workflows/cli-templates/prompts/memory/claude-layer2-domain.txt"
         analysis_strategy="@{*/CLAUDE.md}"
     elif [[ "$clean_path" =~ ^[^/]+/[^/]+$ ]]; then
         # Second-level directories (e.g., .claude/scripts, src/components)
         layer="Layer 3 (Module)"
-        template_path="$HOME/.claude/workflows/cli-templates/prompts/dms/claude-layer3-module.txt"
+        template_path="$HOME/.claude/workflows/cli-templates/prompts/memory/claude-layer3-module.txt"
         analysis_strategy="@{*/CLAUDE.md}"
     else
         # Deeper directories (e.g., .claude/workflows/cli-templates/prompts)
         layer="Layer 4 (Sub-Module)"
-        template_path="$HOME/.claude/workflows/cli-templates/prompts/dms/claude-layer4-submodule.txt"
+        template_path="$HOME/.claude/workflows/cli-templates/prompts/memory/claude-layer4-submodule.txt"
         analysis_strategy="--all-files"
     fi
     

.claude/version.json

@@ -0,0 +1,7 @@
+{
+  "version": "3.3.0",
+  "installation_mode": "Local",
+  "installation_path": "D:\\Claude_dms3\\.claude",
+  "source_branch": "main",
+  "installation_date_utc": "2025-10-04T00:00:00Z"
+}

.claude/workflows/cli-templates/prompts/memory/hierarchy-analysis.txt

@@ -1,4 +1,4 @@
-Analyze project structure for DMS hierarchy optimization:
+Analyze project structure for memory hierarchy optimization:
 
 ## Required Analysis:
 1. Assess project complexity and file organization patterns

.claude/workflows/context-search-strategy.md

@@ -6,6 +6,12 @@ type: search-guideline
 
 # Context Search Strategy
 
+## ⚡ Execution Environment
+
+**CRITICAL**: All commands execute in **Bash environment** (Git Bash on Windows, Bash on Linux/macOS)
+
+**❌ Forbidden**: Windows-specific commands (`findstr`, `dir`, `where`, `type`, `copy`, `del`) - Use Bash equivalents (`grep`, `find`, `which`, `cat`, `cp`, `rm`)
+
 ## ⚡ Core Search Tools
 
 **rg (ripgrep)**: Fast content search with regex support
@@ -18,6 +24,7 @@ type: search-guideline
 - **Use find for files** - Locate files/directories by name
 - **Use grep sparingly** - Only when rg unavailable
 - **Use get_modules_by_depth.sh first** - MANDATORY for program architecture analysis before planning
+- **Always use Bash commands** - NEVER use Windows cmd/PowerShell commands
 
 ### Quick Command Reference
 ```bash

.claude/workflows/intelligent-tools-strategy.md

@@ -18,6 +18,7 @@ type: strategic-guideline
 - **Default to tools** - Use specialized tools for most coding tasks, no matter how small
 - **Lower barriers** - Engage tools immediately when encountering any complexity
 - **Context optimization** - Based on user intent, determine whether to use `-C [directory]` parameter for focused analysis to reduce irrelevant context import
+- **⚠️ Write operation protection** - For local codebase write/modify operations, require EXPLICIT user confirmation unless user provides clear instructions containing MODE=write or MODE=auto
 
 ### Quick Decision Rules
 1. **Exploring/Understanding?** → Start with Gemini
@@ -33,27 +34,33 @@ type: strategic-guideline
 - **Override When Needed**: Specify custom timeout for longer operations
 
 ### Permission Framework
-- **Gemini/Qwen Write Access**: Use `--approval-mode yolo` when tools need to create/modify files
+- **⚠️ WRITE PROTECTION**: Local codebase write/modify requires EXPLICIT user confirmation
-- **Codex Write Access**: Always use `-s danger-full-access` and `--skip-git-repo-check` for development and file operations
+  - **Analysis Mode (default)**: Read-only, safe for auto-execution
-- **Auto-approval Protocol**: Enable automatic tool approvals for autonomous workflow execution
+  - **Write Mode**: Requires user explicitly states MODE=write or MODE=auto in prompt
+  - **Exception**: User provides clear instructions like "modify", "create", "implement"
+- **Gemini/Qwen Write Access**: Use `--approval-mode yolo` ONLY when MODE=write explicitly specified
+- **Codex Write Access**: Use `-s danger-full-access` and `--skip-git-repo-check` ONLY when MODE=auto explicitly specified
+- **Default Behavior**: All tools default to analysis/read-only mode without explicit write permission
 
 ## 🎯 Universal Command Template
 
 ### Standard Format (REQUIRED)
 ```bash
-# Gemini Analysis
+# Gemini Analysis (read/write capable)
 cd [directory] && ~/.claude/scripts/gemini-wrapper -p "
 PURPOSE: [clear analysis goal]
 TASK: [specific analysis task]
+MODE: [analysis|write]
 CONTEXT: [file references and memory context]
 EXPECTED: [expected output]
 RULES: [template reference and constraints]
 "
 
-# Qwen Architecture & Code Generation
+# Qwen Architecture Analysis (read-only analysis)
 cd [directory] && ~/.claude/scripts/qwen-wrapper -p "
-PURPOSE: [clear architecture/code goal]
+PURPOSE: [clear architecture goal]
-TASK: [specific architecture/code task]
+TASK: [specific analysis task]
+MODE: analysis
 CONTEXT: [file references and memory context]
 EXPECTED: [expected deliverables]
 RULES: [template reference and constraints]
@@ -63,6 +70,7 @@ RULES: [template reference and constraints]
 codex -C [directory] --full-auto exec "
 PURPOSE: [clear development goal]
 TASK: [specific development task]
+MODE: [auto|write]
 CONTEXT: [file references and memory context]
 EXPECTED: [expected deliverables]
 RULES: [template reference and constraints]
@@ -72,10 +80,28 @@ RULES: [template reference and constraints]
 ### Template Structure
 - [ ] **PURPOSE** - Clear goal and intent
 - [ ] **TASK** - Specific execution task
+- [ ] **MODE** - Execution mode and permission level
 - [ ] **CONTEXT** - File references and memory context from previous sessions
 - [ ] **EXPECTED** - Clear expected results
 - [ ] **RULES** - Template reference and constraints
 
+### MODE Field Definition
+
+The MODE field controls execution behavior and file permissions:
+
+**For Gemini**:
+- `analysis` (default) - Read-only analysis and documentation generation
+- `write` - ⚠️ Create/modify codebase files (requires explicit specification, auto-enables --approval-mode yolo)
+
+**For Qwen**:
+- `analysis` (default) - Architecture analysis only, no code generation/modification (read-only)
+- `write` - ⚠️ Code generation (requires explicit specification, disabled by default)
+
+**For Codex**:
+- `auto` - ⚠️ Autonomous development with full file operations (requires explicit specification, enables -s danger-full-access)
+- `write` - ⚠️ Test generation and file modification (requires explicit specification)
+- **Default**: No default mode, MODE must be explicitly specified
+
 ### Directory Context
 Tools execute in current working directory:
 - **Gemini**: `cd path/to/project && ~/.claude/scripts/gemini-wrapper -p "prompt"`
@@ -150,80 +176,100 @@ When planning any coding task, **ALWAYS** integrate CLI tools:
 
 ### Common Scenarios
 ```bash
-# Project Analysis (in current directory)
+# Gemini - Code Analysis
 ~/.claude/scripts/gemini-wrapper -p "
 PURPOSE: Understand codebase architecture
 TASK: Analyze project structure and identify patterns
+MODE: analysis
 CONTEXT: @{src/**/*.ts,CLAUDE.md} Previous analysis of auth system
 EXPECTED: Architecture overview and integration points
-RULES: $(cat "~/.claude/workflows/cli-templates/prompts/analysis/architecture.txt") | Focus on integration points
+RULES: $(cat '~/.claude/workflows/cli-templates/prompts/analysis/architecture.txt') | Focus on integration points
 "
 
-# Project Analysis (in different directory)
+# Gemini - Generate Documentation
-cd ../other-project && ~/.claude/scripts/gemini-wrapper -p "
+~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: Compare authentication patterns
+PURPOSE: Generate API documentation
-TASK: Analyze auth implementation in related project
+TASK: Create comprehensive API reference from code
-CONTEXT: @{src/auth/**/*} Current project context from session memory
+MODE: write
-EXPECTED: Pattern comparison and recommendations
+CONTEXT: @{src/api/**/*}
-RULES: $(cat "~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt") | Focus on architectural differences
+EXPECTED: API.md with all endpoints documented
+RULES: Follow project documentation standards
 "
 
-# Architecture Design (with Qwen)
+# Qwen - Architecture Analysis
 cd src/auth && ~/.claude/scripts/qwen-wrapper -p "
-PURPOSE: Design authentication system architecture
+PURPOSE: Analyze authentication system architecture
-TASK: Create modular JWT-based auth system design
+TASK: Review JWT-based auth system design
+MODE: analysis
 CONTEXT: @{src/auth/**/*} Existing patterns and requirements
-EXPECTED: Complete architecture with code scaffolding
+EXPECTED: Architecture analysis report with recommendations
-RULES: $(cat "~/.claude/workflows/cli-templates/prompts/analysis/architecture.txt") | Focus on modularity and security
+RULES: $(cat '~/.claude/workflows/cli-templates/prompts/analysis/architecture.txt') | Focus on security
 "
 
-# Feature Development (in target directory)
+# Codex - Feature Development
 codex -C path/to/project --full-auto exec "
 PURPOSE: Implement user authentication
 TASK: Create JWT-based authentication system
+MODE: auto
 CONTEXT: @{src/auth/**/*} Database schema from session memory
 EXPECTED: Complete auth module with tests
-RULES: $(cat "~/.claude/workflows/cli-templates/prompts/development/feature.txt") | Follow security best practices
+RULES: $(cat '~/.claude/workflows/cli-templates/prompts/development/feature.txt') | Follow security best practices
 " --skip-git-repo-check -s danger-full-access
 
-# Code Review Preparation
+# Codex - Test Generation
-~/.claude/scripts/gemini-wrapper -p "
+codex -C src/auth --full-auto exec "
-PURPOSE: Prepare comprehensive code review
+PURPOSE: Increase test coverage
-TASK: Analyze code changes and identify potential issues
+TASK: Generate comprehensive tests for auth module
-CONTEXT: @{**/*.modified} Recent changes discussed in last session
+MODE: write
-EXPECTED: Review checklist and improvement suggestions
+CONTEXT: @{**/*.ts} Exclude existing tests
-RULES: $(cat "~/.claude/workflows/cli-templates/prompts/analysis/quality.txt") | Focus on maintainability
+EXPECTED: Complete test suite with 80%+ coverage
-"
+RULES: Use Jest, follow existing patterns
+" --skip-git-repo-check -s danger-full-access
 ```
 
 ## 📋 Planning Checklist
 
 For every development task:
 - [ ] **Purpose defined** - Clear goal and intent
+- [ ] **Mode selected** - Execution mode and permission level determined
 - [ ] **Context gathered** - File references and session memory documented
 - [ ] **Gemini analysis** completed for understanding
 - [ ] **Template selected** - Appropriate template chosen
 - [ ] **Constraints specified** - File patterns, scope, requirements
 - [ ] **Implementation approach** - Tool selection and workflow
 - [ ] **Quality measures** - Testing and validation plan
+- [ ] **Tool configuration** - Review `.gemini/CLAUDE.md` or `.codex/Agent.md` if needed
 
 ## 🎯 Key Features
 
 ### Gemini
 - **Command**: `~/.claude/scripts/gemini-wrapper`
 - **Strengths**: Large context window, pattern recognition
-- **Best For**: Analysis, architecture review, code exploration
+- **Best For**: Analysis, documentation generation, code exploration
+- **Permissions**: Default read-only analysis, MODE=write requires explicit specification (auto-enables --approval-mode yolo)
+- **Default MODE**: `analysis` (read-only)
+- **⚠️ Write Trigger**: Only when user explicitly requests "generate documentation", "modify code", or specifies MODE=write
 
 ### Qwen
 - **Command**: `~/.claude/scripts/qwen-wrapper`
-- **Strengths**: Architecture analysis, code generation, implementation patterns
+- **Strengths**: Architecture analysis, pattern recognition
-- **Best For**: System design, code scaffolding, architectural planning
+- **Best For**: System design analysis, architectural review
+- **Permissions**: Architecture analysis only, no automatic code generation
+- **Default MODE**: `analysis` (read-only)
+- **⚠️ Write Trigger**: Explicitly prohibited from auto-calling write mode
 
 ### Codex
 - **Command**: `codex --full-auto exec`
 - **Strengths**: Autonomous development, mathematical reasoning
 - **Best For**: Implementation, testing, automation
-- **Required**: `-s danger-full-access` and `--skip-git-repo-check` for development
+- **Permissions**: Requires explicit MODE=auto or MODE=write specification
+- **Default MODE**: No default, must be explicitly specified
+- **⚠️ Write Trigger**: Only when user explicitly requests "implement", "modify", "generate code" AND specifies MODE
+- **Session Management**:
+  - `codex resume` - Resume previous interactive session (picker by default)
+  - `codex exec "task" resume --last` - Continue most recent session with new task (maintains context)
+  - `codex -i <image_file>` - Attach image(s) to initial prompt (useful for UI/design references)
+  - **Multi-task Pattern**: First task uses `exec`, subsequent tasks use `exec "..." resume --last` for context continuity
 
 ### File Patterns
 - All files: `@{**/*}`
@@ -250,15 +296,33 @@ For every development task:
 
 **Example**:
 ```bash
-# Focused analysis (preferred)
+# Gemini - Focused analysis
-cd src/auth && ~/.claude/scripts/gemini-wrapper -p "analyze auth patterns"
+cd src/auth && ~/.claude/scripts/gemini-wrapper -p "
+PURPOSE: Understand authentication patterns
+TASK: Analyze auth implementation
+MODE: analysis
+CONTEXT: @{**/*.ts}
+EXPECTED: Pattern documentation
+RULES: Focus on security best practices
+"
 
-# Focused architecture (Qwen)
+# Qwen - Architecture analysis
-cd src/auth && ~/.claude/scripts/qwen-wrapper -p "design auth architecture"
+cd src/auth && ~/.claude/scripts/qwen-wrapper -p "
+PURPOSE: Analyze auth architecture
+TASK: Review auth system design and patterns
+MODE: analysis
+CONTEXT: @{**/*}
+EXPECTED: Architecture analysis report
+RULES: Focus on modularity and security
+"
 
-# Focused implementation (Codex)
+# Codex - Implementation
-codex -C src/auth --full-auto exec "analyze auth implementation" --skip-git-repo-check
+codex -C src/auth --full-auto exec "
-
+PURPOSE: Improve auth implementation
-# Multi-scope (stay in root)
+TASK: Review and enhance auth code
-~/.claude/scripts/gemini-wrapper -p "CONTEXT: @{src/auth/**/*,src/api/**/*}"
+MODE: auto
+CONTEXT: @{**/*.ts}
+EXPECTED: Code improvements and fixes
+RULES: Maintain backward compatibility
+" --skip-git-repo-check -s danger-full-access
 ```

.claude/workflows/task-core.md

@@ -49,7 +49,8 @@ All task files use this simplified 5-field schema (aligned with workflow-archite
     },
     "target_files": [
       "src/auth/login.ts:handleLogin:75-120",
-      "src/middleware/auth.ts:validateToken"
+      "src/middleware/auth.ts:validateToken",
+      "src/auth/PasswordReset.ts"
     ]
   }
 }
@@ -81,7 +82,7 @@ All task files use this simplified 5-field schema (aligned with workflow-archite
 **Components**:
 - **pre_analysis**: Array of sequential process steps
 - **implementation_approach**: Task execution strategy
-- **target_files**: Specific files to modify in "file:function:lines" format
+- **target_files**: Files to modify/create - existing files in `file:function:lines` format, new files as `file` only
 
 **Step Structure**:
 ```json

.claude/workflows/workflow-architecture.md

@@ -175,7 +175,8 @@ All task files use this unified 5-field schema with optional artifacts enhanceme
     },
     "target_files": [
       "src/auth/login.ts:handleLogin:75-120",
-      "src/middleware/auth.ts:validateToken"
+      "src/middleware/auth.ts:validateToken",
+      "src/auth/PasswordReset.ts"
     ]
   }
 }
@@ -219,7 +220,7 @@ The **flow_control** field manages task execution with two main components:
 - **task_description**: Comprehensive implementation description
 - **modification_points**: Specific code modification targets
 - **logic_flow**: Business logic execution sequence
-- **target_files**: Target file list in `file:function:lines` format
+- **target_files**: Target file list - existing files in `file:function:lines` format, new files as `file` only
 
 #### Tool Reference
 **Command Types Available**:

.codex/AGENTS.md

@@ -0,0 +1,340 @@
+# Codex Agent Execution Protocol
+
+## Overview
+
+**Role**: Codex - autonomous development, implementation, and testing
+
+## Prompt Structure
+
+### Single-Task Format
+
+**Receive prompts in this format**:
+
+```
+PURPOSE: [development goal]
+TASK: [specific implementation task]
+MODE: [auto|write]
+CONTEXT: [file patterns]
+EXPECTED: [deliverables]
+RULES: [constraints and templates]
+```
+
+### Multi-Task Format (Subtask Execution)
+
+**First subtask** (creates new session):
+```
+PURPOSE: [overall goal]
+TASK: [subtask 1 description]
+MODE: auto
+CONTEXT: [file patterns]
+EXPECTED: [subtask deliverables]
+RULES: [constraints]
+Subtask 1 of N: [subtask title]
+```
+
+**Subsequent subtasks** (continues via `resume --last`):
+```
+CONTINUE TO NEXT SUBTASK:
+Subtask N of M: [subtask title]
+
+PURPOSE: [continuation goal]
+TASK: [subtask N description]
+CONTEXT: Previous work completed, now focus on [new files]
+EXPECTED: [subtask deliverables]
+RULES: Build on previous subtask, maintain consistency
+```
+
+## Execution Requirements
+
+### ALWAYS
+
+- **Parse all fields** - Understand PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES
+- **Detect subtask format** - Check for "Subtask N of M" or "CONTINUE TO NEXT SUBTASK"
+- **Follow MODE strictly** - Respect execution boundaries
+- **Study CONTEXT files** - Find 3+ similar patterns before implementing
+- **Apply RULES** - Follow templates and constraints exactly
+- **Test continuously** - Run tests after every change
+- **Commit incrementally** - Small, working commits
+- **Match project style** - Follow existing patterns exactly
+- **Validate EXPECTED** - Ensure all deliverables are met
+- **Report context** (subtasks) - Summarize key info for next subtask
+
+### NEVER
+
+- **Make assumptions** - Verify with existing code
+- **Ignore existing patterns** - Study before implementing
+- **Skip tests** - Tests are mandatory
+- **Use clever tricks** - Choose boring, obvious solutions
+- **Over-engineer** - Simple solutions over complex architectures
+- **Break existing code** - Ensure backward compatibility
+- **Exceed 3 attempts** - Stop and reassess if blocked 3 times
+
+## MODE Behavior
+
+### MODE: auto (default)
+
+**Permissions**:
+- Full file operations (create/modify/delete)
+- Run tests and builds
+- Commit code incrementally
+
+**Execute (Single Task)**:
+1. Parse PURPOSE and TASK
+2. Analyze CONTEXT files - find 3+ similar patterns
+3. Plan implementation approach
+4. Generate code following RULES and project patterns
+5. Write tests alongside code
+6. Run tests continuously
+7. Commit working code incrementally
+8. Validate all EXPECTED deliverables
+9. Report results
+
+**Execute (Multi-Task/Subtask)**:
+1. **First subtask**: Follow single-task flow above
+2. **Subsequent subtasks** (via `resume --last`):
+   - Recall context from previous subtask(s)
+   - Build on previous work (don't repeat)
+   - Maintain consistency with previous decisions
+   - Focus on current subtask scope only
+   - Test integration with previous subtasks
+   - Report subtask completion status
+
+**Use For**: Feature implementation, bug fixes, refactoring, multi-step tasks
+
+### MODE: write
+
+**Permissions**:
+- Focused file operations
+- Create/modify specific files
+- Run tests for validation
+
+**Execute**:
+1. Analyze CONTEXT files
+2. Make targeted changes
+3. Validate tests pass
+4. Report file changes
+
+**Use For**: Test generation, documentation updates, targeted fixes
+
+## RULES Processing
+
+- **Parse the RULES field** to identify template content and additional constraints
+- **Recognize `|` as separator** between template and additional constraints
+- **ALWAYS apply all template guidelines** provided in the prompt
+- **ALWAYS apply all additional constraints** specified after `|`
+- **Treat all rules as mandatory** - both template and constraints must be followed
+- **Failure to follow any rule** constitutes task failure
+
+## Error Handling
+
+### Three-Attempt Rule
+
+**On 3rd failed attempt**:
+1. **Stop execution**
+2. **Report status**: What was attempted, what failed, root cause
+3. **Request guidance**: Ask for clarification, suggest alternatives
+
+### Recovery Strategies
+
+**Syntax/Type Errors**:
+1. Review and fix errors
+2. Re-run tests
+3. Validate build succeeds
+
+**Runtime Errors**:
+1. Analyze stack trace
+2. Add error handling
+3. Add tests for error cases
+
+**Test Failures**:
+1. Debug in isolation
+2. Review test setup
+3. Fix implementation or test
+
+**Build Failures**:
+1. Check error messages
+2. Fix incrementally
+3. Validate each fix
+
+## Progress Reporting
+
+### During Execution (Single Task)
+
+```
+[1/5] Analyzing existing code patterns...
+[2/5] Planning implementation approach...
+[3/5] Generating code...
+[4/5] Writing tests...
+[5/5] Running validation...
+```
+
+### During Execution (Subtask)
+
+```
+[Subtask N/M: Subtask Title]
+[1/4] Recalling context from previous subtasks...
+[2/4] Implementing current subtask...
+[3/4] Testing integration with previous work...
+[4/4] Validating subtask completion...
+```
+
+### On Success (Single Task)
+
+```
+✅ Task completed
+
+Changes:
+- Created: [files with line counts]
+- Modified: [files with changes]
+
+Validation:
+✅ Tests: [count] passing
+✅ Coverage: [percentage]
+✅ Build: Success
+
+Next Steps: [recommendations]
+```
+
+### On Success (Subtask)
+
+```
+✅ Subtask N/M completed
+
+Changes:
+- Created: [files]
+- Modified: [files]
+
+Integration:
+✅ Compatible with previous subtasks
+✅ Tests: [count] passing
+✅ Build: Success
+
+Context for next subtask:
+- [Key decisions made]
+- [Files created/modified]
+- [Patterns established]
+```
+
+### On Partial Completion
+
+```
+⚠️ Task partially completed
+
+Completed: [what worked]
+Blocked: [what failed and why]
+Required: [what's needed]
+Recommendation: [next steps]
+```
+
+## Quality Standards
+
+### Code Quality
+- Follow project's existing patterns
+- Match import style and naming conventions
+- Single responsibility per function/class
+- DRY (Don't Repeat Yourself)
+- YAGNI (You Aren't Gonna Need It)
+
+### Testing
+- Test all public functions
+- Test edge cases and error conditions
+- Mock external dependencies
+- Target 80%+ coverage
+
+### Error Handling
+- Proper try-catch blocks
+- Clear error messages
+- Graceful degradation
+- Don't expose sensitive info
+
+## Multi-Step Task Execution
+
+### Context Continuity via Resume
+
+When executing subtasks via `codex exec "..." resume --last`:
+
+**Advantages**:
+- Session memory preserves previous decisions
+- Maintains implementation style consistency
+- Avoids redundant context re-injection
+- Enables incremental testing and validation
+
+**Best Practices**:
+1. **First subtask**: Establish patterns and architecture
+2. **Subsequent subtasks**: Build on established patterns
+3. **Test integration**: After each subtask, verify compatibility
+4. **Report context**: Summarize key decisions for next subtask
+5. **Maintain scope**: Focus only on current subtask goals
+
+### Subtask Coordination
+
+**DO**:
+- Remember decisions from previous subtasks
+- Reuse patterns established earlier
+- Test integration with previous work
+- Report what's ready for next subtask
+
+**DON'T**:
+- Re-implement what previous subtasks completed
+- Change patterns established earlier (unless explicitly requested)
+- Skip testing integration points
+- Assume next subtask's requirements
+
+### Example Flow
+
+```
+Subtask 1: Create data models
+→ Establishes: Schema patterns, validation approach
+→ Delivers: Models with tests
+→ Context for next: Model structure, validation rules
+
+Subtask 2: Implement API endpoints (resume --last)
+→ Recalls: Model structure from subtask 1
+→ Builds on: Uses established models
+→ Delivers: API with integration tests
+→ Context for next: API patterns, error handling
+
+Subtask 3: Add authentication (resume --last)
+→ Recalls: API patterns from subtask 2
+→ Integrates: Auth middleware into existing endpoints
+→ Delivers: Secured API
+→ Final validation: Full integration test
+```
+
+## Philosophy
+
+- **Incremental progress over big bangs** - Small, testable changes
+- **Learning from existing code** - Study 3+ patterns before implementing
+- **Pragmatic over dogmatic** - Adapt to project reality
+- **Clear intent over clever code** - Boring, obvious solutions
+- **Simple over complex** - Avoid over-engineering
+- **Follow existing style** - Match project patterns exactly
+- **Context continuity** - Leverage resume for multi-step consistency
+
+## Execution Checklist
+
+### Before Implementation
+- [ ] Understand PURPOSE and TASK clearly
+- [ ] Review all CONTEXT files
+- [ ] Find 3+ similar patterns in codebase
+- [ ] Check RULES templates and constraints
+- [ ] Plan implementation approach
+
+### During Implementation
+- [ ] Follow existing patterns exactly
+- [ ] Write tests alongside code
+- [ ] Run tests after every change
+- [ ] Commit working code incrementally
+- [ ] Handle errors properly
+
+### After Implementation
+- [ ] Run full test suite - all pass
+- [ ] Check coverage - meets target
+- [ ] Run build - succeeds
+- [ ] Review EXPECTED - all deliverables met
+
+---
+
+**Version**: 2.1.0
+**Last Updated**: 2025-10-04
+**Changes**: Added multi-step task execution support with resume mechanism

.gemini/GEMINI.md

@@ -0,0 +1,143 @@
+# Gemini Execution Protocol
+
+## Overview
+
+**Role**: Gemini - code analysis and documentation generation
+
+## Prompt Structure
+
+**Receive prompts in this format**:
+
+```
+PURPOSE: [goal statement]
+TASK: [specific task]
+MODE: [analysis|write]
+CONTEXT: [file patterns]
+EXPECTED: [deliverables]
+RULES: [constraints and templates]
+```
+
+## Execution Requirements
+
+### ALWAYS
+
+- **Parse all six fields** - Understand PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES
+- **Follow MODE strictly** - Respect permission boundaries
+- **Analyze CONTEXT files** - Read all matching patterns thoroughly
+- **Apply RULES** - Follow templates and constraints exactly
+- **Provide evidence** - Quote code with file:line references
+- **Match EXPECTED** - Deliver exactly what's requested
+
+### NEVER
+
+- **Assume behavior** - Verify with actual code
+- **Ignore CONTEXT** - Stay within specified file patterns
+- **Skip RULES** - Templates are mandatory when provided
+- **Make unsubstantiated claims** - Always back with code references
+- **Deviate from MODE** - Respect read/write boundaries
+
+## MODE Behavior
+
+### MODE: analysis (default)
+
+**Permissions**:
+- Read all CONTEXT files
+- Create/modify documentation files
+
+**Execute**:
+1. Read and analyze CONTEXT files
+2. Identify patterns and issues
+3. Generate insights and recommendations
+4. Create documentation if needed
+5. Output structured analysis
+
+**Constraint**: Do NOT modify source code files
+
+### MODE: write
+
+**Permissions**:
+- Full file operations
+- Create/modify any files
+
+**Execute**:
+1. Read CONTEXT files
+2. Perform requested file operations
+3. Create/modify files as specified
+4. Validate changes
+5. Report file changes
+
+## Output Format
+
+### Standard Analysis Structure
+
+```markdown
+# Analysis: [TASK Title]
+
+## Summary
+[2-3 sentence overview]
+
+## Key Findings
+1. [Finding] - path/to/file:123
+2. [Finding] - path/to/file:456
+
+## Detailed Analysis
+[Evidence-based analysis with code quotes]
+
+## Recommendations
+1. [Actionable recommendation]
+2. [Actionable recommendation]
+```
+
+### Code References
+
+Always use format: `path/to/file:line_number`
+
+Example: "Authentication logic at `src/auth/jwt.ts:45` uses deprecated algorithm"
+
+## RULES Processing
+
+- **Parse the RULES field** to identify template content and additional constraints
+- **Recognize `|` as separator** between template and additional constraints
+- **ALWAYS apply all template guidelines** provided in the prompt
+- **ALWAYS apply all additional constraints** specified after `|`
+- **Treat all rules as mandatory** - both template and constraints must be followed
+- **Failure to follow any rule** constitutes task failure
+
+## Error Handling
+
+**File Not Found**:
+- Report missing files
+- Continue with available files
+- Note in output
+
+**Invalid CONTEXT Pattern**:
+- Report invalid pattern
+- Request correction
+- Do not guess
+
+## Quality Standards
+
+### Thoroughness
+- Analyze ALL files in CONTEXT
+- Check cross-file patterns
+- Identify edge cases
+- Quantify when possible
+
+### Evidence-Based
+- Quote relevant code
+- Provide file:line references
+- Link related patterns
+
+### Actionable
+- Clear recommendations
+- Prioritized by impact
+- Specific, not vague
+
+## Philosophy
+
+- **Incremental over big bangs** - Suggest small, testable changes
+- **Learn from existing code** - Reference project patterns
+- **Pragmatic over dogmatic** - Adapt to project reality
+- **Clear over clever** - Prefer obvious solutions
+- **Simple over complex** - Avoid over-engineering
+

CHANGELOG.md

@@ -5,6 +5,241 @@ All notable changes to Claude Code Workflow (CCW) will be documented in this fil
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.3.0] - 2025-10-04
+
+### 🚀 CLI Tool Enhancements & Codex Multi-Step Execution
+
+This release streamlines CLI tool documentation and introduces automated multi-step task execution with Codex.
+
+#### Added
+
+**New Command: `/cli:codex-execute`**:
+- **Purpose**: Automated task decomposition and sequential execution with Codex
+- **Features**:
+  - Automatic task breakdown into 3-8 manageable subtasks
+  - Sequential execution using `codex exec "..." resume --last` mechanism
+  - TodoWrite progress tracking for each subtask
+  - Optional Git verification after each subtask (`--verify-git` flag)
+  - Supports both freeform descriptions and workflow task IDs
+  - Automatic detection and loading of task JSON files
+  - Context continuity across subtasks via resume mechanism
+  - Integration with workflow system (optional)
+
+**Codex Resume Mechanism**:
+- **First Subtask**: Creates new Codex session with `codex exec`
+- **Subsequent Subtasks**: Continues with `codex exec "..." resume --last`
+- **Benefits**:
+  - Session memory preserves previous decisions
+  - Maintains implementation style consistency
+  - Avoids redundant context re-injection
+  - Enables incremental testing and validation
+
+**Enhanced Codex Agent Configuration** (`.codex/AGENTS.md`):
+- Added multi-task prompt format (Single-Task & Multi-Task)
+- Enhanced MODE: auto with subtask execution flow
+- New "Multi-Step Task Execution" section with:
+  - Context continuity best practices
+  - Subtask coordination guidelines
+  - Example 3-subtask workflow demonstration
+- Updated progress reporting for subtasks
+- Version 2.1.0 with multi-step task execution support
+
+#### Changed
+
+**CLI Documentation Optimization**:
+- **Streamlined Documentation**: Reduced redundancy by referencing `intelligent-tools-strategy.md`
+- **Updated Commands**:
+  - `/cli:analyze` - Simplified from ~200 to ~78 lines
+  - `/cli:chat` - Simplified from ~161 to ~92 lines
+  - `/cli:execute` - Simplified from ~235 to ~111 lines
+- **Unified Command Templates**:
+  - Separated Gemini/Qwen (uses `-p` parameter) from Codex (uses `exec` command)
+  - Added Codex `-i` parameter documentation for image attachment
+  - Consistent template structure across all CLI commands
+
+**Intelligent Tools Strategy Updates**:
+- Enhanced Codex session management documentation
+- Added `codex exec "..." resume --last` syntax explanation
+- Documented multi-task execution pattern
+- Clarified image attachment workflow with resume
+
+**Command Template Improvements**:
+- **Gemini/Qwen**: `cd [dir] && ~/.claude/scripts/[tool]-wrapper -p "..."`
+- **Codex**: `codex -C [dir] --full-auto exec "..." --skip-git-repo-check -s danger-full-access`
+- **Codex with Resume**: `codex exec "..." resume --last --skip-git-repo-check -s danger-full-access`
+- **Image Support**: `codex -C [dir] -i image.png --full-auto exec "..."`
+
+#### Technical Details
+
+**Multi-Step Execution Flow**:
+```
+Input → Parse (Description/Task ID) → Decompose into Subtasks → TodoWrite Tracking →
+For Each Subtask:
+  1. Execute with Codex (first: exec, subsequent: exec resume --last)
+  2. [Optional] Git verification
+  3. Mark complete in TodoWrite
+→ Final Summary
+```
+
+**Subtask Decomposition Criteria**:
+- Each subtask: 5-15 minutes completable
+- Clear, testable outcomes
+- Explicit dependencies
+- Focused file scope (1-5 files per subtask)
+
+**Error Handling**:
+- Subtask failure: Pause for user intervention
+- Git verification failure: Request user decision
+- Codex session lost: Attempt retry with fresh session
+
+**Integration Features**:
+- Automatic task ID detection (e.g., `IMPL-001`, `TASK-123`)
+- JSON task loading from `.task/[ID].json`
+- Execution logging to `.chat/codex-execute-[timestamp].md`
+- Summary generation to `.summaries/[TASK-ID]-summary.md`
+
+#### Benefits
+
+**Developer Experience**:
+- 🚀 Automated task breakdown reduces planning overhead
+- 📊 Clear progress tracking with TodoWrite integration
+- 🔄 Context continuity improves code consistency
+- ✅ Optional Git verification ensures code quality
+- 🎯 Focused subtask execution reduces complexity
+
+**Code Quality**:
+- 🧪 Incremental testing after each subtask
+- 🔍 Git verification catches unexpected changes
+- 📝 Comprehensive execution logs for audit trail
+- 🎨 Image attachment support for UI/design tasks
+
+**Documentation**:
+- 📚 Reduced documentation redundancy by ~60%
+- 🔗 Clear references to master documentation
+- ✨ Consistent command structure across all CLI tools
+- 📖 Better separation of concerns (strategy vs. command docs)
+
+---
+
+## [3.2.3] - 2025-10-03
+
+### ✨ Version Management System
+
+This release introduces a comprehensive version management and upgrade notification system.
+
+#### Added
+
+**New Command: `/version`**:
+- **Purpose**: Display version information and check for updates from GitHub
+- **Features**:
+  - Shows local and global installation versions
+  - Fetches latest stable release from GitHub API
+  - Displays latest development commit from main branch
+  - Compares installed versions with remote versions
+  - Provides upgrade recommendations with installation commands
+  - Supports both stable and development version tracking
+
+**Version Information Display**:
+- **Local Version**: Shows project-specific installation (if exists)
+- **Global Version**: Shows `~/.claude` installation with tracking mode
+- **Latest Stable**: Displays latest release tag, name, and publish date
+- **Latest Dev**: Shows latest commit hash, message, and date
+- **Status Assessment**: Automatic version comparison and upgrade suggestions
+
+**Version Tracking Files**:
+- **`.claude/version.json`**: Local project version tracking
+- **`~/.claude/version.json`**: Global installation version tracking
+- **Fields**:
+  - `version`: Version number or "latest" for main branch tracking
+  - `installation_mode`: "Local" or "Global"
+  - `installation_path`: Installation directory
+  - `source_branch`: Source branch (usually "main")
+  - `installation_date_utc`: ISO 8601 timestamp
+
+**GitHub API Integration**:
+- **Latest Release**: `https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest`
+  - Extracts: `tag_name`, `name`, `published_at`
+- **Latest Commit**: `https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main`
+  - Extracts: `sha`, `commit.message`, `commit.author.date`
+- **Timeout**: 30-second timeout for slow connections
+- **Error Handling**: Graceful fallback for network errors
+
+**Command Output Scenarios**:
+
+1. **Up to date**:
+   ```
+   ✅ You are on the latest stable version (3.2.3)
+   ```
+
+2. **Upgrade available**:
+   ```
+   ⬆️ A newer stable version is available: v3.2.3
+   Your version: 3.2.2
+
+   To upgrade:
+   PowerShell: iex (iwr -useb https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.ps1)
+   Bash: bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.sh)
+   ```
+
+3. **Development version**:
+   ```
+   ✨ You are running a development version (3.3.0-dev)
+   This is newer than the latest stable release (v3.2.3)
+   ```
+
+#### Changed
+
+**Documentation Updates**:
+- Added `/version` command reference to README.md
+- Added version management documentation to README_CN.md
+- Created comprehensive `.claude/commands/version.md` implementation guide
+- Updated command tables with version management examples
+
+**Installation Scripts Enhancement**:
+- Installation scripts now create `version.json` files automatically
+- Track installation mode (local vs global)
+- Record installation timestamp
+- Support version tracking for both stable and development installations
+
+#### Technical Details
+
+**Implementation**:
+- Uses simple bash commands (no jq dependency required)
+- Fallback to grep/sed for JSON parsing
+- Network calls with curl and error suppression
+- Version comparison using `sort -V` for semantic versioning
+- Cross-platform compatible (Windows Git Bash, Linux, macOS)
+
+**Command Structure**:
+```bash
+/version                    # Display version and check for updates
+```
+
+**No parameters required** - command automatically:
+1. Checks local version file (`./.claude/version.json`)
+2. Checks global version file (`~/.claude/version.json`)
+3. Fetches latest release from GitHub
+4. Fetches latest commit from main branch
+5. Compares versions and provides recommendations
+
+#### Benefits
+
+**User Experience**:
+- 🔍 Quick version check with single command
+- 📊 Comprehensive version information display
+- 🔄 Automatic upgrade notifications
+- 📈 Development version tracking support
+- 🌐 GitHub API integration for latest updates
+
+**DevOps**:
+- 📁 Version tracking in both local and global installations
+- 🕐 Installation timestamp for audit trails
+- 🔀 Support for both stable and development branches
+- ⚡ Fast execution with 30-second network timeout
+- 🛡️ Graceful error handling for offline scenarios
+
+---
+
 ## [3.2.0] - 2025-10-02
 
 ### 🔄 Test-Fix Workflow & Agent Architecture Simplification

CLAUDE.md

@@ -19,11 +19,14 @@ For all CLI tool usage, command syntax, and integration guidelines:
 
 ### Core Beliefs
 
+- **Pursue good taste** - Eliminate edge cases to make code logic natural and elegant
+- **Embrace extreme simplicity** - Complexity is the root of all evil
+- **Be pragmatic** - Code must solve real-world problems, not hypothetical ones
+- **Data structures first** - Bad programmers worry about code; good programmers worry about data structures
+- **Never break backward compatibility** - Existing functionality is sacred and inviolable
 - **Incremental progress over big bangs** - Small changes that compile and pass tests
 - **Learning from existing code** - Study and plan before implementing
-- **Pragmatic over dogmatic** - Adapt to project reality
 - **Clear intent over clever code** - Be boring and obvious
-- **Simple solutions over complex architectures** - Avoid over-engineering and premature optimization
 - **Follow existing code style** - Match import patterns, naming conventions, and formatting of existing codebase
 
 ### Simplicity Means

INSTALL.md

@@ -186,7 +186,7 @@ cd Dmsflow
 .\Install-Claude.ps1 -Global
 
 # 4. Start using Claude Code with Agent workflows!
-# Use /workflow commands and DMS system for development
+# Use /workflow commands and memory system for development
 ```
 
 ## Verification
@@ -207,7 +207,7 @@ After installation, verify:
    - Check that global `.claude` directory is recognized
    - Verify workflow commands and DMS commands are available
    - Test `/workflow` commands for agent coordination
-   - Test `/dmsflow version` to check version information
+   - Test `/workflow version` to check version information
 
 ## Troubleshooting
 

INSTALL_CN.md

@@ -162,7 +162,7 @@ cd Dmsflow
 .\Install-Claude.ps1 -Global
 
 # 4. 开始使用 Claude Code Agent 工作流！
-# 使用 /workflow 命令和 DMS 系统进行开发
+# 使用 /workflow 命令和内存系统进行开发
 ```
 
 ## 验证
@@ -181,9 +181,9 @@ cd Dmsflow
 2. **测试 Claude Code：**
    - 在项目中打开 Claude Code
    - 检查全局 `.claude` 目录是否被识别
-   - 验证工作流命令和 DMS 命令是否可用
+   - 验证工作流命令和内存命令是否可用
    - 测试 `/workflow` 命令的 Agent 协调功能
-   - 测试 `/dmsflow version` 检查版本信息
+   - 测试 `/workflow version` 检查版本信息
 
 ## 故障排除
 

Install-Claude.ps1

@@ -59,7 +59,11 @@ param(
 
     [switch]$BackupAll,
 
-    [switch]$NoBackup
+    [switch]$NoBackup,
+
+    [string]$SourceVersion = "",
+
+    [string]$SourceBranch = ""
 )
 
 # Set encoding for proper Unicode support
@@ -156,22 +160,34 @@ function Test-Prerequisites {
         Write-ColorOutput "Current version: $($PSVersionTable.PSVersion)" $ColorError
         return $false
     }
-    
+
     # Test source files exist
     $sourceDir = $PSScriptRoot
     $claudeDir = Join-Path $sourceDir ".claude"
     $claudeMd = Join-Path $sourceDir "CLAUDE.md"
-    
+    $codexDir = Join-Path $sourceDir ".codex"
+    $geminiDir = Join-Path $sourceDir ".gemini"
+
     if (-not (Test-Path $claudeDir)) {
         Write-ColorOutput "ERROR: .claude directory not found in $sourceDir" $ColorError
         return $false
     }
-    
+
     if (-not (Test-Path $claudeMd)) {
         Write-ColorOutput "ERROR: CLAUDE.md file not found in $sourceDir" $ColorError
         return $false
     }
-    
+
+    if (-not (Test-Path $codexDir)) {
+        Write-ColorOutput "ERROR: .codex directory not found in $sourceDir" $ColorError
+        return $false
+    }
+
+    if (-not (Test-Path $geminiDir)) {
+        Write-ColorOutput "ERROR: .gemini directory not found in $sourceDir" $ColorError
+        return $false
+    }
+
     Write-ColorOutput "Prerequisites check passed" $ColorSuccess
     return $true
 }
@@ -610,6 +626,37 @@ function Merge-DirectoryContents {
     return $true
 }
 
+function Create-VersionJson {
+    param(
+        [string]$TargetClaudeDir,
+        [string]$InstallationMode
+    )
+
+    # Determine version from source or default
+    $versionNumber = if ($SourceVersion) { $SourceVersion } else { $Version }
+    $sourceBranch = if ($SourceBranch) { $SourceBranch } else { "unknown" }
+
+    # Create version.json content
+    $versionInfo = @{
+        version = $versionNumber
+        installation_mode = $InstallationMode
+        installation_path = $TargetClaudeDir
+        installation_date_utc = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+        source_branch = $sourceBranch
+    }
+
+    $versionJsonPath = Join-Path $TargetClaudeDir "version.json"
+
+    try {
+        $versionInfo | ConvertTo-Json | Out-File -FilePath $versionJsonPath -Encoding utf8 -Force
+        Write-ColorOutput "Created version.json: $versionNumber ($InstallationMode)" $ColorSuccess
+        return $true
+    } catch {
+        Write-ColorOutput "WARNING: Failed to create version.json: $($_.Exception.Message)" $ColorWarning
+        return $false
+    }
+}
+
 function Install-Global {
     Write-ColorOutput "Installing Claude Code Workflow System globally..." $ColorInfo
 
@@ -617,6 +664,8 @@ function Install-Global {
     $userProfile = [Environment]::GetFolderPath("UserProfile")
     $globalClaudeDir = Join-Path $userProfile ".claude"
     $globalClaudeMd = Join-Path $globalClaudeDir "CLAUDE.md"
+    $globalCodexDir = Join-Path $userProfile ".codex"
+    $globalGeminiDir = Join-Path $userProfile ".gemini"
 
     Write-ColorOutput "Global installation path: $userProfile" $ColorInfo
 
@@ -624,12 +673,23 @@ function Install-Global {
     $sourceDir = $PSScriptRoot
     $sourceClaudeDir = Join-Path $sourceDir ".claude"
     $sourceClaudeMd = Join-Path $sourceDir "CLAUDE.md"
+    $sourceCodexDir = Join-Path $sourceDir ".codex"
+    $sourceGeminiDir = Join-Path $sourceDir ".gemini"
 
     # Create backup folder if needed (default behavior unless NoBackup is specified)
     $backupFolder = $null
     if (-not $NoBackup) {
-        if (Test-Path $globalClaudeDir) {
+        if ((Test-Path $globalClaudeDir) -or (Test-Path $globalCodexDir) -or (Test-Path $globalGeminiDir)) {
-            $existingFiles = Get-ChildItem $globalClaudeDir -Recurse -File -ErrorAction SilentlyContinue
+            $existingFiles = @()
+            if (Test-Path $globalClaudeDir) {
+                $existingFiles += Get-ChildItem $globalClaudeDir -Recurse -File -ErrorAction SilentlyContinue
+            }
+            if (Test-Path $globalCodexDir) {
+                $existingFiles += Get-ChildItem $globalCodexDir -Recurse -File -ErrorAction SilentlyContinue
+            }
+            if (Test-Path $globalGeminiDir) {
+                $existingFiles += Get-ChildItem $globalGeminiDir -Recurse -File -ErrorAction SilentlyContinue
+            }
             if (($existingFiles -and ($existingFiles | Measure-Object).Count -gt 0)) {
                 $backupFolder = Get-BackupDirectory -TargetDirectory $userProfile
                 Write-ColorOutput "Backup folder created: $backupFolder" $ColorInfo
@@ -649,6 +709,18 @@ function Install-Global {
     Write-ColorOutput "Installing CLAUDE.md to global .claude directory..." $ColorInfo
     $claudeMdInstalled = Copy-FileToDestination -Source $sourceClaudeMd -Destination $globalClaudeMd -Description "CLAUDE.md" -BackupFolder $backupFolder
 
+    # Merge .codex directory contents
+    Write-ColorOutput "Merging .codex directory contents..." $ColorInfo
+    $codexMerged = Merge-DirectoryContents -Source $sourceCodexDir -Destination $globalCodexDir -Description ".codex directory contents" -BackupFolder $backupFolder
+
+    # Merge .gemini directory contents
+    Write-ColorOutput "Merging .gemini directory contents..." $ColorInfo
+    $geminiMerged = Merge-DirectoryContents -Source $sourceGeminiDir -Destination $globalGeminiDir -Description ".gemini directory contents" -BackupFolder $backupFolder
+
+    # Create version.json in global .claude directory
+    Write-ColorOutput "Creating version.json..." $ColorInfo
+    Create-VersionJson -TargetClaudeDir $globalClaudeDir -InstallationMode "Global"
+
     if ($backupFolder -and (Test-Path $backupFolder)) {
         $backupFiles = Get-ChildItem $backupFolder -Recurse -File -ErrorAction SilentlyContinue
         if (-not $backupFiles -or ($backupFiles | Measure-Object).Count -eq 0) {
@@ -679,14 +751,18 @@ function Install-Path {
     $sourceDir = $PSScriptRoot
     $sourceClaudeDir = Join-Path $sourceDir ".claude"
     $sourceClaudeMd = Join-Path $sourceDir "CLAUDE.md"
+    $sourceCodexDir = Join-Path $sourceDir ".codex"
+    $sourceGeminiDir = Join-Path $sourceDir ".gemini"
 
-    # Local paths - only for agents, commands, output-styles
+    # Local paths - for agents, commands, output-styles, .codex, .gemini
     $localClaudeDir = Join-Path $TargetDirectory ".claude"
+    $localCodexDir = Join-Path $TargetDirectory ".codex"
+    $localGeminiDir = Join-Path $TargetDirectory ".gemini"
 
     # Create backup folder if needed
     $backupFolder = $null
     if (-not $NoBackup) {
-        if ((Test-Path $localClaudeDir) -or (Test-Path $globalClaudeDir)) {
+        if ((Test-Path $localClaudeDir) -or (Test-Path $localCodexDir) -or (Test-Path $localGeminiDir) -or (Test-Path $globalClaudeDir)) {
             $backupFolder = Get-BackupDirectory -TargetDirectory $TargetDirectory
             Write-ColorOutput "Backup folder created: $backupFolder" $ColorInfo
         }
@@ -774,6 +850,22 @@ function Install-Path {
     Write-ColorOutput "Installing CLAUDE.md to global .claude directory..." $ColorInfo
     Copy-FileToDestination -Source $sourceClaudeMd -Destination $globalClaudeMd -Description "CLAUDE.md" -BackupFolder $backupFolder
 
+    # Merge .codex directory contents to local location
+    Write-ColorOutput "Merging .codex directory contents to local location..." $ColorInfo
+    $codexMerged = Merge-DirectoryContents -Source $sourceCodexDir -Destination $localCodexDir -Description ".codex directory contents" -BackupFolder $backupFolder
+
+    # Merge .gemini directory contents to local location
+    Write-ColorOutput "Merging .gemini directory contents to local location..." $ColorInfo
+    $geminiMerged = Merge-DirectoryContents -Source $sourceGeminiDir -Destination $localGeminiDir -Description ".gemini directory contents" -BackupFolder $backupFolder
+
+    # Create version.json in local .claude directory
+    Write-ColorOutput "Creating version.json in local directory..." $ColorInfo
+    Create-VersionJson -TargetClaudeDir $localClaudeDir -InstallationMode "Path"
+
+    # Also create version.json in global .claude directory
+    Write-ColorOutput "Creating version.json in global directory..." $ColorInfo
+    Create-VersionJson -TargetClaudeDir $globalClaudeDir -InstallationMode "Global"
+
     if ($backupFolder -and (Test-Path $backupFolder)) {
         $backupFiles = Get-ChildItem $backupFolder -Recurse -File -ErrorAction SilentlyContinue
         if (-not $backupFiles -or ($backupFiles | Measure-Object).Count -eq 0) {
@@ -879,10 +971,11 @@ function Show-Summary {
     if ($Mode -eq "Path") {
         Write-Host "  Local Path: $Path"
         Write-Host "  Global Path: $([Environment]::GetFolderPath('UserProfile'))"
-        Write-Host "  Local Components: agents, commands, output-styles"
+        Write-Host "  Local Components: agents, commands, output-styles, .codex, .gemini"
         Write-Host "  Global Components: workflows, scripts, python_script, etc."
     } else {
         Write-Host "  Path: $Path"
+        Write-Host "  Global Components: .claude, .codex, .gemini"
     }
 
     if ($NoBackup) {
@@ -896,10 +989,12 @@ function Show-Summary {
     Write-Host ""
     Write-ColorOutput "Next steps:" $ColorInfo
     Write-Host "1. Review CLAUDE.md - Customize guidelines for your project"
-    Write-Host "2. Configure settings - Edit .claude/settings.local.json as needed"
+    Write-Host "2. Review .codex/Agent.md - Codex agent execution protocol"
-    Write-Host "3. Start using Claude Code with Agent workflow coordination!"
+    Write-Host "3. Review .gemini/CLAUDE.md - Gemini agent execution protocol"
-    Write-Host "4. Use /workflow commands for task execution"
+    Write-Host "4. Configure settings - Edit .claude/settings.local.json as needed"
-    Write-Host "5. Use /update-memory commands for memory system management"
+    Write-Host "5. Start using Claude Code with Agent workflow coordination!"
+    Write-Host "6. Use /workflow commands for task execution"
+    Write-Host "7. Use /update-memory commands for memory system management"
 
     Write-Host ""
     Write-ColorOutput "Documentation: https://github.com/catlog22/Claude-CCW" $ColorInfo

Install-Claude.sh

@@ -87,8 +87,8 @@ function show_header() {
 
 function test_prerequisites() {
     # Test bash version
-    if [ "${BASH_VERSINFO[0]}" -lt 4 ]; then
+    if [ "${BASH_VERSINFO[0]}" -lt 2 ]; then
-        write_color "ERROR: Bash 4.0 or higher is required" "$COLOR_ERROR"
+        write_color "ERROR: Bash 2.0 or higher is required" "$COLOR_ERROR"
         write_color "Current version: ${BASH_VERSION}" "$COLOR_ERROR"
         return 1
     fi
@@ -97,6 +97,8 @@ function test_prerequisites() {
     local script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
     local claude_dir="$script_dir/.claude"
     local claude_md="$script_dir/CLAUDE.md"
+    local codex_dir="$script_dir/.codex"
+    local gemini_dir="$script_dir/.gemini"
 
     if [ ! -d "$claude_dir" ]; then
         write_color "ERROR: .claude directory not found in $script_dir" "$COLOR_ERROR"
@@ -108,6 +110,16 @@ function test_prerequisites() {
         return 1
     fi
 
+    if [ ! -d "$codex_dir" ]; then
+        write_color "ERROR: .codex directory not found in $script_dir" "$COLOR_ERROR"
+        return 1
+    fi
+
+    if [ ! -d "$gemini_dir" ]; then
+        write_color "ERROR: .gemini directory not found in $script_dir" "$COLOR_ERROR"
+        return 1
+    fi
+
     write_color "✓ Prerequisites check passed" "$COLOR_SUCCESS"
     return 0
 }
@@ -389,6 +401,8 @@ function install_global() {
     local user_home="$HOME"
     local global_claude_dir="${user_home}/.claude"
     local global_claude_md="${global_claude_dir}/CLAUDE.md"
+    local global_codex_dir="${user_home}/.codex"
+    local global_gemini_dir="${user_home}/.gemini"
 
     write_color "Global installation path: $user_home" "$COLOR_INFO"
 
@@ -396,14 +410,25 @@ function install_global() {
     local script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
     local source_claude_dir="${script_dir}/.claude"
     local source_claude_md="${script_dir}/CLAUDE.md"
+    local source_codex_dir="${script_dir}/.codex"
+    local source_gemini_dir="${script_dir}/.gemini"
 
     # Create backup folder if needed
     local backup_folder=""
     if [ "$NO_BACKUP" = false ]; then
+        local has_existing_files=false
+
         if [ -d "$global_claude_dir" ] && [ "$(ls -A "$global_claude_dir" 2>/dev/null)" ]; then
-            backup_folder=$(get_backup_directory "$user_home")
+            has_existing_files=true
-            write_color "Backup folder created: $backup_folder" "$COLOR_INFO"
+        elif [ -d "$global_codex_dir" ] && [ "$(ls -A "$global_codex_dir" 2>/dev/null)" ]; then
+            has_existing_files=true
+        elif [ -d "$global_gemini_dir" ] && [ "$(ls -A "$global_gemini_dir" 2>/dev/null)" ]; then
+            has_existing_files=true
         elif [ -f "$global_claude_md" ]; then
+            has_existing_files=true
+        fi
+
+        if [ "$has_existing_files" = true ]; then
             backup_folder=$(get_backup_directory "$user_home")
             write_color "Backup folder created: $backup_folder" "$COLOR_INFO"
         fi
@@ -417,6 +442,14 @@ function install_global() {
     write_color "Installing CLAUDE.md to global .claude directory..." "$COLOR_INFO"
     copy_file_to_destination "$source_claude_md" "$global_claude_md" "CLAUDE.md" "$backup_folder"
 
+    # Merge .codex directory contents
+    write_color "Merging .codex directory contents..." "$COLOR_INFO"
+    merge_directory_contents "$source_codex_dir" "$global_codex_dir" ".codex directory contents" "$backup_folder"
+
+    # Merge .gemini directory contents
+    write_color "Merging .gemini directory contents..." "$COLOR_INFO"
+    merge_directory_contents "$source_gemini_dir" "$global_gemini_dir" ".gemini directory contents" "$backup_folder"
+
     # Remove empty backup folder
     if [ -n "$backup_folder" ] && [ -d "$backup_folder" ]; then
         if [ -z "$(ls -A "$backup_folder" 2>/dev/null)" ]; then
@@ -442,14 +475,18 @@ function install_path() {
     local script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
     local source_claude_dir="${script_dir}/.claude"
     local source_claude_md="${script_dir}/CLAUDE.md"
+    local source_codex_dir="${script_dir}/.codex"
+    local source_gemini_dir="${script_dir}/.gemini"
 
     # Local paths
     local local_claude_dir="${target_dir}/.claude"
+    local local_codex_dir="${target_dir}/.codex"
+    local local_gemini_dir="${target_dir}/.gemini"
 
     # Create backup folder if needed
     local backup_folder=""
     if [ "$NO_BACKUP" = false ]; then
-        if [ -d "$local_claude_dir" ] || [ -d "$global_claude_dir" ]; then
+        if [ -d "$local_claude_dir" ] || [ -d "$local_codex_dir" ] || [ -d "$local_gemini_dir" ] || [ -d "$global_claude_dir" ]; then
             backup_folder=$(get_backup_directory "$target_dir")
             write_color "Backup folder created: $backup_folder" "$COLOR_INFO"
         fi
@@ -530,6 +567,14 @@ function install_path() {
     write_color "Installing CLAUDE.md to global .claude directory..." "$COLOR_INFO"
     copy_file_to_destination "$source_claude_md" "$global_claude_md" "CLAUDE.md" "$backup_folder"
 
+    # Merge .codex directory contents to local location
+    write_color "Merging .codex directory contents to local location..." "$COLOR_INFO"
+    merge_directory_contents "$source_codex_dir" "$local_codex_dir" ".codex directory contents" "$backup_folder"
+
+    # Merge .gemini directory contents to local location
+    write_color "Merging .gemini directory contents to local location..." "$COLOR_INFO"
+    merge_directory_contents "$source_gemini_dir" "$local_gemini_dir" ".gemini directory contents" "$backup_folder"
+
     # Remove empty backup folder
     if [ -n "$backup_folder" ] && [ -d "$backup_folder" ]; then
         if [ -z "$(ls -A "$backup_folder" 2>/dev/null)" ]; then
@@ -631,10 +676,11 @@ function show_summary() {
     if [ "$mode" = "Path" ]; then
         echo "  Local Path: $path"
         echo "  Global Path: $HOME"
-        echo "  Local Components: agents, commands, output-styles"
+        echo "  Local Components: agents, commands, output-styles, .codex, .gemini"
         echo "  Global Components: workflows, scripts, python_script, etc."
     else
         echo "  Path: $path"
+        echo "  Global Components: .claude, .codex, .gemini"
     fi
 
     if [ "$NO_BACKUP" = true ]; then
@@ -648,10 +694,12 @@ function show_summary() {
     echo ""
     write_color "Next steps:" "$COLOR_INFO"
     echo "1. Review CLAUDE.md - Customize guidelines for your project"
-    echo "2. Configure settings - Edit .claude/settings.local.json as needed"
+    echo "2. Review .codex/Agent.md - Codex agent execution protocol"
-    echo "3. Start using Claude Code with Agent workflow coordination!"
+    echo "3. Review .gemini/CLAUDE.md - Gemini agent execution protocol"
-    echo "4. Use /workflow commands for task execution"
+    echo "4. Configure settings - Edit .claude/settings.local.json as needed"
-    echo "5. Use /update-memory commands for memory system management"
+    echo "5. Start using Claude Code with Agent workflow coordination!"
+    echo "6. Use /workflow commands for task execution"
+    echo "7. Use /update-memory commands for memory system management"
 
     echo ""
     write_color "Documentation: https://github.com/catlog22/Claude-Code-Workflow" "$COLOR_INFO"

PROJECT_INTRODUCTION.md

@@ -1,6 +1,6 @@
 # 🚀 Claude Code Workflow (CCW): 下一代多智能体软件开发自动化框架
 
-[![Version](https://img.shields.io/badge/version-v2.1.0--experimental-blue.svg)](https://github.com/catlog22/Claude-Code-Workflow/releases)
+[![Version](https://img.shields.io/badge/version-v3.2.1-blue.svg)](https://github.com/catlog22/Claude-Code-Workflow/releases)
 [![MCP工具](https://img.shields.io/badge/🔧_MCP工具-实验性-orange.svg)](https://github.com/modelcontextprotocol)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 

README.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-[![Version](https://img.shields.io/badge/version-v3.1.0-blue.svg)](https://github.com/catlog22/Claude-Code-Workflow/releases)
+[![Version](https://img.shields.io/badge/version-v3.3.0-blue.svg)](https://github.com/catlog22/Claude-Code-Workflow/releases)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-lightgrey.svg)]()
 [![MCP Tools](https://img.shields.io/badge/🔧_MCP_Tools-Experimental-orange.svg)](https://github.com/modelcontextprotocol)
@@ -15,9 +15,15 @@
 
 **Claude Code Workflow (CCW)** is a next-generation multi-agent automation framework that orchestrates complex software development tasks through intelligent workflow management and autonomous execution.
 
-> **🎉 Latest: v3.1.0** - TDD Workflow Support with Red-Green-Refactor cycle enforcement. See [CHANGELOG.md](CHANGELOG.md) for details.
+> **🎉 Latest: v3.3.0** - CLI tool enhancements & Codex multi-step execution. See [CHANGELOG.md](CHANGELOG.md) for details.
 >
-> **v3.0.0**: Introduced **unified CLI command structure**. The `/cli:*` commands consolidate all tool interactions (Gemini, Qwen, Codex) using a `--tool` flag for selection.
+> **What's New in v3.3.0**:
+> - 🚀 New `/cli:codex-execute` command for automated multi-step task execution
+> - 🔄 Codex resume mechanism (`codex exec "..." resume --last`) for context continuity
+> - 📋 TodoWrite progress tracking for subtask execution
+> - 📚 Streamlined CLI documentation (60% reduction in redundancy)
+> - 🔧 Enhanced Codex agent configuration for multi-task workflows
+> - ✅ Optional Git verification after each subtask completion
 
 ---
 
@@ -49,12 +55,93 @@ Invoke-Expression (Invoke-WebRequest -Uri "https://raw.githubusercontent.com/cat
 bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.sh)
 ```
 
+### **📋 Interactive Version Selection**
+
+After running the installation command, you'll see an interactive menu with real-time version information:
+
+```
+Detecting latest release and commits...
+Latest stable: v3.2.0 (2025-10-02 04:27 UTC)
+Latest commit: cdea58f (2025-10-02 08:15 UTC)
+
+====================================================
+            Version Selection Menu
+====================================================
+
+1) Latest Stable Release (Recommended)
+   |-- Version: v3.2.0
+   |-- Released: 2025-10-02 04:27 UTC
+   \-- Production-ready
+
+2) Latest Development Version
+   |-- Branch: main
+   |-- Commit: cdea58f
+   |-- Updated: 2025-10-02 08:15 UTC
+   |-- Cutting-edge features
+   \-- May contain experimental changes
+
+3) Specific Release Version
+   |-- Install a specific tagged release
+   \-- Recent: v3.2.0, v3.1.0, v3.0.1
+
+====================================================
+
+Select version to install (1-3, default: 1):
+```
+
+**Version Options:**
+- **Option 1 (Recommended)**: Latest stable release with verified production quality
+- **Option 2**: Latest development version from main branch with newest features
+- **Option 3**: Specific version tag for controlled deployments
+
+> 💡 **Pro Tip**: The installer automatically detects and displays the latest version numbers and release dates from GitHub. Just press Enter to select the recommended stable release.
+
+### **📦 Local Installation (Install-Claude.ps1)**
+
+For local installation without network access, use the bundled PowerShell installer:
+
+**Installation Modes:**
+```powershell
+# Interactive mode with prompts (recommended)
+.\Install-Claude.ps1
+
+# Quick install with automatic backup
+.\Install-Claude.ps1 -Force -BackupAll
+
+# Non-interactive install
+.\Install-Claude.ps1 -NonInteractive -Force
+```
+
+**Installation Options:**
+
+| Mode | Description | Installs To |
+|------|-------------|-------------|
+| **Global** | System-wide installation (default) | `~/.claude/`, `~/.codex/`, `~/.gemini/` |
+| **Path** | Custom directory + global hybrid | Local: `agents/`, `commands/`<br>Global: `workflows/`, `scripts/` |
+
+**Backup Behavior:**
+- **Default**: Automatic backup enabled (`-BackupAll`)
+- **Disable**: Use `-NoBackup` flag (⚠️ overwrites without backup)
+- **Backup location**: `claude-backup-{timestamp}/` in installation directory
+
+**⚠️ Important Warnings:**
+- `-Force -BackupAll`: Silent file overwrite (with backup)
+- `-NoBackup -Force`: Permanent file overwrite (no recovery)
+- Global mode modifies user profile directories
+
 ### **✅ Verify Installation**
 After installation, run the following command to ensure CCW is working:
 ```bash
 /workflow:session:list
 ```
 
+> **📝 Installation Notes:**
+> - The installer will automatically install/update `.codex/` and `.gemini/` directories
+> - **Global mode**: Installs to `~/.codex` and `~/.gemini`
+> - **Path mode**: Installs to your specified directory (e.g., `project/.codex`, `project/.gemini`)
+> - **Backup**: Existing files are backed up by default to `claude-backup-{timestamp}/`
+> - **Safety**: Use interactive mode for first-time installation to review changes
+
 ---
 
 ## 🚀 Getting Started
@@ -91,9 +178,9 @@ After installation, run the following command to ensure CCW is working:
 
 **Phase 4: Testing & Quality Assurance**
 ```bash
-# Generate comprehensive test suite (standard workflow)
+# Generate independent test-fix workflow (v3.2.2+)
-/workflow:test-gen
+/workflow:test-gen WFS-auth  # Creates WFS-test-auth session
-/workflow:execute
+/workflow:execute            # Runs test validation
 
 # OR verify TDD compliance (TDD workflow)
 /workflow:tdd-verify
@@ -117,6 +204,22 @@ After installation, run the following command to ensure CCW is working:
 /workflow:execute
 ```
 
+> **💡 When to Use Which Approach?**
+>
+> **Use `/workflow:plan` + `/workflow:execute` for:**
+> - Complex features requiring multiple modules (>3 modules)
+> - Tasks with multiple subtasks (>5 subtasks)
+> - Cross-cutting changes affecting architecture
+> - Features requiring coordination between components
+> - When you need structured planning and progress tracking
+>
+> **Use Claude Code directly for:**
+> - Simple, focused changes (single file or module)
+> - Quick bug fixes with clear solutions
+> - Documentation updates
+> - Code refactoring within one component
+> - Straightforward feature additions
+
 **Code Analysis:**
 ```bash
 # Deep codebase analysis
@@ -150,7 +253,7 @@ After installation, run the following command to ensure CCW is working:
 | `/workflow:tdd-plan` | Create a Test-Driven Development workflow with Red-Green-Refactor cycles. |
 | `/workflow:execute` | Execute the current workflow plan autonomously. |
 | `/workflow:status` | Display the current status of the workflow. |
-| `/workflow:test-gen` | Automatically generate a test plan from the implementation. |
+| `/workflow:test-gen` | Create independent test-fix workflow for validating completed implementation. |
 | `/workflow:tdd-verify` | Verify TDD compliance and generate quality report. |
 | `/workflow:review` | **Optional** manual review (only use when explicitly needed - passing tests = approved code). |
 
@@ -161,11 +264,47 @@ After installation, run the following command to ensure CCW is working:
 | `/task:*` | Manage individual tasks (`create`, `breakdown`, `execute`, `replan`). |
 | `/update-memory-full` | Re-index the entire project documentation. |
 | `/update-memory-related` | Update documentation related to recent changes. |
+| `/version` | Display version information and check for updates from GitHub. |
 
 ---
 
 ## ⚙️ Configuration
 
+### **Prerequisites: Required Tools**
+
+Before using CCW, install the following command-line tools:
+
+#### **Core CLI Tools**
+
+| Tool | Purpose | Installation |
+|------|---------|--------------|
+| **Gemini CLI** | AI analysis & documentation | `npm install -g @google/gemini-cli` ([GitHub](https://github.com/google-gemini/gemini-cli)) |
+| **Codex CLI** | AI development & implementation | `npm install -g @openai/codex` ([GitHub](https://github.com/openai/codex)) |
+| **Qwen Code** | AI architecture & code generation | `npm install -g @qwen-code/qwen-code` ([Docs](https://github.com/QwenLM/qwen-code)) |
+
+#### **System Utilities**
+
+| Tool | Purpose | Installation |
+|------|---------|--------------|
+| **ripgrep (rg)** | Fast code search | [Download](https://github.com/BurntSushi/ripgrep/releases) or `brew install ripgrep` (macOS), `apt install ripgrep` (Ubuntu) |
+| **jq** | JSON processing | [Download](https://jqlang.github.io/jq/download/) or `brew install jq` (macOS), `apt install jq` (Ubuntu) |
+
+**Quick Install (All Tools):**
+
+```bash
+# macOS
+brew install ripgrep jq
+npm install -g @google/gemini-cli @openai/codex @qwen-code/qwen-code
+
+# Ubuntu/Debian
+sudo apt install ripgrep jq
+npm install -g @google/gemini-cli @openai/codex @qwen-code/qwen-code
+
+# Windows (Chocolatey)
+choco install ripgrep jq
+npm install -g @google/gemini-cli @openai/codex @qwen-code/qwen-code
+```
+
 ### **Essential: Gemini CLI Setup**
 
 Configure Gemini CLI for optimal integration:
@@ -173,7 +312,7 @@ Configure Gemini CLI for optimal integration:
 ```json
 // ~/.gemini/settings.json
 {
-  "contextFileName": "CLAUDE.md"
+  "contextFileName": ["CLAUDE.md", "GEMINI.md"]
 }
 ```
 
@@ -204,7 +343,7 @@ MCP (Model Context Protocol) tools provide advanced codebase analysis. **Complet
 
 | MCP Server | Purpose | Installation Guide |
 |------------|---------|-------------------|
-| **Exa MCP** | External API patterns & best practices | [Install Guide](https://github.com/exa-labs/exa-mcp-server) |
+| **Exa MCP** | External API patterns & best practices | [Install Guide](https://smithery.ai/server/exa) |
 | **Code Index MCP** | Advanced internal code search | [Install Guide](https://github.com/johnhuang316/code-index-mcp) |
 
 #### Benefits When Enabled

README_CN.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-[![Version](https://img.shields.io/badge/version-v3.1.0-blue.svg)](https://github.com/catlog22/Claude-Code-Workflow/releases)
+[![Version](https://img.shields.io/badge/version-v3.3.0-blue.svg)](https://github.com/catlog22/Claude-Code-Workflow/releases)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-lightgrey.svg)]()
 [![MCP工具](https://img.shields.io/badge/🔧_MCP工具-实验性-orange.svg)](https://github.com/modelcontextprotocol)
@@ -15,9 +15,15 @@
 
 **Claude Code Workflow (CCW)** 是一个新一代的多智能体自动化开发框架，通过智能工作流管理和自主执行来协调复杂的软件开发任务。
 
-> **🎉 最新版本: v3.1.0** - TDD 工作流支持，包含 Red-Green-Refactor 循环强制执行。详见 [CHANGELOG.md](CHANGELOG.md)。
+> **🎉 最新版本: v3.3.0** - CLI 工具增强与 Codex 多步骤执行。详见 [CHANGELOG.md](CHANGELOG.md)。
 >
-> **v3.0.0 版本**: 引入了**统一的 CLI 命令结构**。`/cli:*` 命令通过 `--tool` 标志整合了所有工具（Gemini, Qwen, Codex）的交互。
+> **v3.3.0 版本新特性**:
+> - 🚀 新增 `/cli:codex-execute` 命令，实现自动化多步骤任务执行
+> - 🔄 Codex resume 机制（`codex exec "..." resume --last`），保持上下文连续性
+> - 📋 TodoWrite 进度跟踪，监控子任务执行状态
+> - 📚 精简 CLI 文档（减少 60% 冗余内容）
+> - 🔧 增强 Codex 智能体配置，支持多任务工作流
+> - ✅ 可选的 Git 验证，每个子任务完成后检查代码变更
 
 ---
 
@@ -49,12 +55,93 @@ Invoke-Expression (Invoke-WebRequest -Uri "https://raw.githubusercontent.com/cat
 bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.sh)
 ```
 
+### **📋 交互式版本选择**
+
+运行安装命令后，您将看到包含实时版本信息的交互式菜单：
+
+```
+正在检测最新版本和提交...
+最新稳定版: v3.2.0 (2025-10-02 04:27 UTC)
+最新提交: cdea58f (2025-10-02 08:15 UTC)
+
+====================================================
+            版本选择菜单
+====================================================
+
+1) 最新稳定版（推荐）
+   |-- 版本: v3.2.0
+   |-- 发布时间: 2025-10-02 04:27 UTC
+   \-- 生产就绪
+
+2) 最新开发版
+   |-- 分支: main
+   |-- 提交: cdea58f
+   |-- 更新时间: 2025-10-02 08:15 UTC
+   |-- 最新功能
+   \-- 可能包含实验性更改
+
+3) 指定版本
+   |-- 安装特定标签版本
+   \-- 最近版本: v3.2.0, v3.1.0, v3.0.1
+
+====================================================
+
+选择要安装的版本 (1-3, 默认: 1):
+```
+
+**版本选项：**
+- **选项 1（推荐）**：经过验证的最新稳定版本，生产环境可用
+- **选项 2**：来自 main 分支的最新开发版本，包含最新功能
+- **选项 3**：指定版本标签，用于受控部署
+
+> 💡 **提示**：安装程序会自动从 GitHub 检测并显示最新的版本号和发布日期。只需按 Enter 键即可选择推荐的稳定版本。
+
+### **📦 本地安装 (Install-Claude.ps1)**
+
+无需网络访问时，使用内置的 PowerShell 安装脚本：
+
+**安装模式：**
+```powershell
+# 交互式安装（推荐）
+.\Install-Claude.ps1
+
+# 快速安装（自动备份）
+.\Install-Claude.ps1 -Force -BackupAll
+
+# 非交互式安装
+.\Install-Claude.ps1 -NonInteractive -Force
+```
+
+**安装选项：**
+
+| 模式 | 描述 | 安装位置 |
+|------|------|----------|
+| **Global** | 系统级安装（默认） | `~/.claude/`、`~/.codex/`、`~/.gemini/` |
+| **Path** | 自定义目录 + 全局混合 | 本地：`agents/`、`commands/`<br>全局：`workflows/`、`scripts/` |
+
+**备份行为：**
+- **默认**：自动备份启用（`-BackupAll`）
+- **禁用**：使用 `-NoBackup` 标志（⚠️ 无备份覆盖）
+- **备份位置**：安装目录中的 `claude-backup-{timestamp}/`
+
+**⚠️ 重要警告：**
+- `-Force -BackupAll`：静默文件覆盖（带备份）
+- `-NoBackup -Force`：永久文件覆盖（无法恢复）
+- Global 模式会修改用户配置目录
+
 ### **✅ 验证安装**
 安装后，运行以下命令以确保 CCW 正常工作：
 ```bash
 /workflow:session:list
 ```
 
+> **📝 安装说明：**
+> - 安装程序将自动安装/更新 `.codex/` 和 `.gemini/` 目录
+> - **全局模式**：安装到 `~/.codex` 和 `~/.gemini`
+> - **路径模式**：安装到指定目录（例如 `project/.codex`、`project/.gemini`）
+> - **备份**：默认自动备份现有文件到 `claude-backup-{timestamp}/`
+> - **安全**：首次安装建议使用交互式模式以审查更改
+
 ---
 
 ## 🚀 快速入门
@@ -91,15 +178,12 @@ bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflo
 
 **阶段 4：测试与质量保证**
 ```bash
-# 生成全面测试套件（标准工作流）
+# 生成独立测试修复工作流（v3.2.2+）
-/workflow:test-gen
+/workflow:test-gen WFS-auth  # 创建 WFS-test-auth 会话
-/workflow:execute
+/workflow:execute            # 运行测试验证
 
 # 或验证 TDD 合规性（TDD 工作流）
 /workflow:tdd-verify
-
-# 可选：手动审查（仅在明确需要时使用）
-# /workflow:review  # 测试通过 = 代码已批准
 ```
 
 ### 简单任务快速入门
@@ -120,6 +204,22 @@ bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflo
 /workflow:execute
 ```
 
+> **💡 何时使用哪种方式？**
+>
+> **使用 `/workflow:plan` + `/workflow:execute` 适用于：**
+> - 需要多个模块的复杂功能（>3 个模块）
+> - 包含多个子任务的任务（>5 个子任务）
+> - 影响架构的横切变更
+> - 需要组件间协调的功能
+> - 需要结构化规划和进度跟踪时
+>
+> **直接使用 Claude Code 适用于：**
+> - 简单、聚焦的变更（单个文件或模块）
+> - 解决方案明确的快速 bug 修复
+> - 文档更新
+> - 单个组件内的代码重构
+> - 简单直接的功能添加
+
 **代码分析：**
 ```bash
 # 深度代码库分析
@@ -153,7 +253,7 @@ bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflo
 | `/workflow:tdd-plan` | 创建测试驱动开发工作流，包含 Red-Green-Refactor 循环。 |
 | `/workflow:execute` | 自主执行当前的工作流计划。 |
 | `/workflow:status` | 显示工作流的当前状态。 |
-| `/workflow:test-gen` | 从实现中自动生成测试计划。 |
+| `/workflow:test-gen` | 创建独立测试修复工作流，用于验证已完成的实现。 |
 | `/workflow:tdd-verify` | 验证 TDD 合规性并生成质量报告。 |
 | `/workflow:review` | **可选** 手动审查（仅在明确需要时使用，测试通过即代表代码已批准）。 |
 
@@ -164,11 +264,47 @@ bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflo
 | `/task:*` | 管理单个任务（`create`, `breakdown`, `execute`, `replan`）。 |
 | `/update-memory-full` | 重新索引整个项目文档。 |
 | `/update-memory-related` | 更新与最近更改相关的文档。 |
+| `/version` | 显示版本信息并检查 GitHub 更新。 |
 
 ---
 
 ## ⚙️ 配置
 
+### **前置要求：必需工具**
+
+在使用 CCW 之前，请安装以下命令行工具：
+
+#### **核心 CLI 工具**
+
+| 工具 | 用途 | 安装方式 |
+|------|------|----------|
+| **Gemini CLI** | AI 分析与文档生成 | `npm install -g @google/gemini-cli` ([GitHub](https://github.com/google-gemini/gemini-cli)) |
+| **Codex CLI** | AI 开发与实现 | `npm install -g @openai/codex` ([GitHub](https://github.com/openai/codex)) |
+| **Qwen Code** | AI 架构与代码生成 | `npm install -g @qwen-code/qwen-code` ([文档](https://github.com/QwenLM/qwen-code)) |
+
+#### **系统实用工具**
+
+| 工具 | 用途 | 安装方式 |
+|------|------|----------|
+| **ripgrep (rg)** | 快速代码搜索 | [下载](https://github.com/BurntSushi/ripgrep/releases) 或 `brew install ripgrep` (macOS), `apt install ripgrep` (Ubuntu) |
+| **jq** | JSON 处理 | [下载](https://jqlang.github.io/jq/download/) 或 `brew install jq` (macOS), `apt install jq` (Ubuntu) |
+
+**快速安装（所有工具）：**
+
+```bash
+# macOS
+brew install ripgrep jq
+npm install -g @google/gemini-cli @openai/codex @qwen-code/qwen-code
+
+# Ubuntu/Debian
+sudo apt install ripgrep jq
+npm install -g @google/gemini-cli @openai/codex @qwen-code/qwen-code
+
+# Windows (Chocolatey)
+choco install ripgrep jq
+npm install -g @google/gemini-cli @openai/codex @qwen-code/qwen-code
+```
+
 ### **必需: Gemini CLI 设置**
 
 配置 Gemini CLI 以实现最佳集成：
@@ -176,7 +312,7 @@ bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflo
 ```json
 // ~/.gemini/settings.json
 {
-  "contextFileName": "CLAUDE.md"
+  "contextFileName": ["CLAUDE.md", "GEMINI.md"]
 }
 ```
 
@@ -207,7 +343,7 @@ MCP (模型上下文协议) 工具提供高级代码库分析。**完全可选**
 
 | MCP 服务器 | 用途 | 安装指南 |
 |------------|------|---------|
-| **Exa MCP** | 外部 API 模式和最佳实践 | [安装指南](https://github.com/exa-labs/exa-mcp-server) |
+| **Exa MCP** | 外部 API 模式和最佳实践 | [安装指南](https://smithery.ai/server/exahttps://smithery.ai/server/exa) |
 | **Code Index MCP** | 高级内部代码搜索 | [安装指南](https://github.com/johnhuang316/code-index-mcp) |
 
 #### 启用后的好处

RELEASE_NOTES_v2.0.md

@@ -1,264 +0,0 @@
-# 🚀 Claude Code Workflow (CCW) v2.0.0 Release Notes
-
-**Release Date**: September 28, 2025
-**Release Type**: Major Version Release
-**Repository**: https://github.com/catlog22/Claude-Code-Workflow
-
----
-
-## 📋 Overview
-
-Claude Code Workflow v2.0 represents a **major architectural evolution** with significant enhancements to the multi-agent automation framework. This release introduces a comprehensive four-layer architecture, enhanced workflow lifecycle management, and intelligent tech stack detection.
-
-> **🎯 Upgrade Recommendation**: This is a **breaking change release** with significant architectural improvements. Review the breaking changes section before upgrading.
-
----
-
-## 🌟 Major Features & Enhancements
-
-### 🏗️ **Four-Layer Architecture (NEW)**
-
-CCW now operates through four distinct architectural layers with defined responsibilities and data contracts:
-
-| Layer | Components | Data Flow | Integration Points |
-|-------|------------|-----------|-------------------|
-| **🖥️ Interface Layer** | CLI Commands, Gemini/Codex/Qwen Wrappers | User input → Commands → Agents | External CLI tools, approval modes |
-| **📋 Session Layer** | `.active-[session]` markers, `workflow-session.json` | Session state → Task discovery | Atomic session switching |
-| **📊 Task/Data Layer** | `.task/impl-*.json`, hierarchy management | Task definitions → Agent execution | JSON-first model, generated views |
-| **🤖 Orchestration Layer** | Multi-agent coordination, dependency resolution | Agent outputs → Task updates | Intelligent execution flow |
-
-### 🔄 **Enhanced Workflow Lifecycle**
-
-Complete development lifecycle with quality gates at each phase:
-
-1. **💡 Brainstorm Phase** - Multi-perspective conceptual planning with role-based analysis
-2. **📋 Plan Phase** - Structured implementation planning with task decomposition
-3. **✅ Verify Phase** - Pre-execution validation using Gemini (strategic) + Codex (technical)
-4. **⚡ Execute Phase** - Autonomous implementation with multi-agent orchestration
-5. **🧪 Test Phase** - Automated test workflow generation with comprehensive coverage
-6. **🔍 Review Phase** - Quality assurance and completion validation
-
-### 🧪 **Automated Test Generation**
-
-Comprehensive test workflow creation:
-- **Implementation Analysis**: Scans completed IMPL-* tasks for test requirements
-- **Multi-layered Testing**: Unit, Integration, E2E, Performance, Security tests
-- **Agent Assignment**: Specialized test agents for different test types
-- **Dependency Mapping**: Test execution follows implementation dependency chains
-
-### ✅ **Plan Verification System**
-
-Dual-engine validation before execution:
-- **Gemini Strategic Analysis**: High-level feasibility and architectural soundness
-- **Codex Technical Analysis**: Implementation details and technical feasibility
-- **Cross-Validation**: Identifies conflicts between strategic vision and technical constraints
-- **Improvement Suggestions**: Actionable recommendations before implementation begins
-
-### 🧠 **Smart Tech Stack Detection**
-
-Intelligent task-based loading of technology guidelines:
-- **Automatic Detection**: Only loads tech stacks for development and code review tasks
-- **Multi-Language Support**: TypeScript, React, Python, Java, Go, JavaScript
-- **Performance Optimized**: Skips detection for non-relevant tasks
-- **Context-Aware**: Applies appropriate tech stack principles to development work
-
-### 🔮 **Qwen CLI Integration**
-
-Full integration of Qwen CLI for architecture analysis and code generation:
-- **Architecture Analysis**: System design patterns and code quality assessment
-- **Code Generation**: Implementation scaffolding and component creation
-- **Intelligent Modes**: Auto template selection and precise architectural planning
-
----
-
-## 📊 New Commands & Capabilities
-
-### **Issue Management Commands**
-- `➕ /workflow:issue:create` - Create new project issues with priority and type
-- `📋 /workflow:issue:list` - List and filter issues by status and assignment
-- `📝 /workflow:issue:update` - Update existing issue status and assignments
-- `✅ /workflow:issue:close` - Close completed issues with resolution reasons
-
-### **Enhanced Workflow Commands**
-- `✅ /workflow:plan-verify` - Pre-execution validation using dual analysis
-- `🧪 /workflow:test-gen` - Generate comprehensive test workflows
-- `🎨 /workflow:brainstorm:artifacts` - Generate structured planning documents
-- `🔍 /workflow:plan-deep` - Deep technical planning with Gemini analysis
-
-### **Qwen CLI Commands**
-- `🔍 /qwen:analyze` - Architecture analysis and code quality assessment
-- `💬 /qwen:chat` - Direct Qwen interaction for design discussions
-- `⚡ /qwen:execute` - Intelligent implementation with YOLO permissions
-- `🚀 /qwen:mode:auto` - Auto template selection and execution
-- `🐛 /qwen:mode:bug-index` - Bug analysis and fix suggestions
-- `📋 /qwen:mode:plan` - Architecture planning and analysis
-
----
-
-## 🔧 Technical Improvements
-
-### **Script & Tool Enhancements**
-- **gemini-wrapper**: Improved token management and path handling
-- **qwen-wrapper**: Streamlined execution and simplified interface
-- **Cross-Platform**: Enhanced Windows path compatibility with proper quoting
-- **Directory Navigation**: Intelligent context optimization for focused analysis
-
-### **Agent Improvements**
-- **Flow Control**: Enhanced sequential execution with context accumulation
-- **Context Assessment**: Smart tech stack loading for relevant tasks only
-- **Error Handling**: Improved per-step error strategies
-- **Variable Passing**: Context transfer between execution steps
-
-### **Documentation Overhaul**
-- **Unified Structure**: Aligned English and Chinese documentation
-- **Command Standardization**: Consistent syntax across all commands
-- **Architecture Clarity**: Clear data flow and integration point descriptions
-- **Version Synchronization**: Both language versions now reflect v2.0 features
-
----
-
-## 📈 Performance & Compatibility
-
-### **Performance Metrics**
-| Metric | Performance | Details |
-|--------|-------------|---------|
-| 🔄 **Session Switching** | <10ms | Atomic marker file operations |
-| 📊 **JSON Queries** | <1ms | Direct JSON access, no parsing overhead |
-| 📝 **Doc Updates** | <30s | Medium projects, intelligent targeting |
-| 🔍 **Context Loading** | <5s | Complex codebases with caching |
-| ⚡ **Task Execution** | 10min timeout | Complex operations with error handling |
-
-### **System Requirements**
-- **🖥️ OS**: Windows 10+, Ubuntu 18.04+, macOS 10.15+
-- **📦 Dependencies**: Git, Node.js (Gemini), Python 3.8+ (Codex)
-- **💾 Storage**: ~50MB core + variable project data
-- **🧠 Memory**: 512MB minimum, 2GB recommended
-
-### **Integration Requirements**
-- **🔍 Gemini CLI**: Required for analysis and strategic planning workflows
-- **🤖 Codex CLI**: Required for autonomous development and bug fixing
-- **🔮 Qwen CLI**: Required for architecture analysis and code generation
-- **📂 Git Repository**: Required for change tracking and version control
-
----
-
-## ⚠️ Breaking Changes
-
-### **Removed Components**
-- **Python CLI Backend**: All `pycli` references and related scripts removed
-- **Deprecated Scripts**: `install_pycli.sh`, `pycli`, `pycli.conf`, `tech-stack-loader.sh`
-- **Legacy Commands**: Old path reading scripts and unused Python tools
-
-### **Command Syntax Changes**
-- **Session Commands**: `/workflow:session list` → `/workflow:session:list`
-- **File Naming**: Standardized to lowercase `.task/impl-*.json`
-- **Session Markers**: Unified format `.active-[session]`
-
-### **Architecture Changes**
-- **Data Model**: Migrated to JSON-first architecture
-- **Session Management**: Atomic marker-based system
-- **Task Structure**: Standardized hierarchy and status management
-
-### **Configuration Updates**
-Required Gemini CLI configuration:
-```json
-{
-  "contextFileName": "CLAUDE.md"
-}
-```
-
----
-
-## 🚀 Migration Guide
-
-### **From v1.x to v2.0**
-
-1. **Update Configuration**:
-   ```bash
-   # Update Gemini CLI settings
-   echo '{"contextFileName": "CLAUDE.md"}' > ~/.gemini/settings.json
-   ```
-
-2. **Clean Legacy Files**:
-   ```bash
-   # Remove old Python CLI references
-   rm -f .claude/scripts/pycli*
-   rm -f .claude/scripts/install_pycli.sh
-   ```
-
-3. **Update Command Usage**:
-   ```bash
-   # Old syntax
-   /workflow:session list
-
-   # New syntax
-   /workflow:session:list
-   ```
-
-4. **Verify Installation**:
-   ```bash
-   /workflow:session:list
-   ```
-
----
-
-## 📚 Documentation & Resources
-
-### **Updated Documentation**
-- **README.md**: Complete v2.0 feature documentation
-- **README_CN.md**: Chinese documentation with v2.0 alignment
-- **Architecture Guides**: Four-layer system documentation
-- **Command Reference**: Comprehensive CLI command tables
-
-### **Quick Start**
-```bash
-# Install CCW v2.0
-Invoke-Expression (Invoke-WebRequest -Uri "https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.ps1" -UseBasicParsing).Content
-
-# Verify installation
-/workflow:session:list
-
-# Start first workflow
-/workflow:session:start "My First Project"
-```
-
----
-
-## 🤝 Contributing & Support
-
-### **Development**
-- **GitHub**: https://github.com/catlog22/Claude-Code-Workflow
-- **Issues**: https://github.com/catlog22/Claude-Code-Workflow/issues
-- **Discussions**: https://github.com/catlog22/Claude-Code-Workflow/discussions
-
-### **Community**
-- **Documentation**: [Project Wiki](https://github.com/catlog22/Claude-Code-Workflow/wiki)
-- **Changelog**: [Release History](CHANGELOG.md)
-- **License**: MIT License
-
----
-
-## 🙏 Acknowledgments
-
-Special thanks to the community for feedback and contributions that made v2.0 possible. This release represents a significant step forward in automated development workflow capabilities.
-
----
-
-**🚀 Claude Code Workflow v2.0**
-
-*Professional software development workflow automation through intelligent multi-agent coordination and autonomous execution capabilities.*
-
----
-
-## 📝 Commit History Summary
-
-This release includes 15+ commits spanning major architectural improvements:
-
-- **5d08c53**: Smart tech stack detection for agents
-- **b956943**: Workflow architecture documentation updates
-- **8baca52**: README v2.0 alignment and four-layer architecture
-- **0756682**: Python CLI cleanup and modernization
-- **be4db94**: Concept evaluation framework addition
-- **817f51c**: Qwen CLI integration and task commands
-
-For complete commit history, see: [GitHub Commits](https://github.com/catlog22/Claude-Code-Workflow/commits/main)

RELEASE_NOTES_v3.2.3.md

@@ -0,0 +1,252 @@
+# v3.2.3 - Version Management System
+
+## 🎉 Release Date
+2025-10-03
+
+## ✨ Overview
+
+This release introduces a comprehensive version management and upgrade notification system, making it easy to track your Claude Code Workflow installation and stay up-to-date with the latest releases.
+
+## 🆕 New Features
+
+### `/version` Command
+
+A powerful new command that provides complete version information and automatic update checking:
+
+**Features:**
+- 📊 **Version Display**: Shows both local and global installation versions
+- 🌐 **GitHub Integration**: Fetches latest stable release and development commits
+- 🔄 **Smart Comparison**: Automatically compares installed version with latest available
+- 💡 **Upgrade Recommendations**: Provides installation commands for easy upgrading
+- ⚡ **Fast Execution**: 30-second timeout for network calls, graceful offline handling
+
+**Usage:**
+```bash
+/version
+```
+
+**Example Output:**
+```
+Installation Status:
+- Local: No project-specific installation
+- Global: ✅ Installed at ~/.claude
+  - Version: v3.2.3
+  - Installed: 2025-10-03T05:01:34Z
+
+Latest Releases:
+- Stable: v3.2.3 (2025-10-03T04:10:08Z)
+  - v3.2.3: Version Management System
+- Latest Commit: c5c36a2 (2025-10-03T05:00:06Z)
+  - fix: Optimize version command API calls and data extraction
+
+Status: ✅ You are on the latest stable version (3.2.3)
+```
+
+### Version Tracking System
+
+**Version Files:**
+- `.claude/version.json` - Local project installation tracking
+- `~/.claude/version.json` - Global installation tracking
+
+**Tracked Information:**
+```json
+{
+  "version": "v3.2.3",
+  "installation_mode": "Global",
+  "installation_path": "C:\\Users\\username\\.claude",
+  "source_branch": "main",
+  "installation_date_utc": "2025-10-03T05:01:34Z"
+}
+```
+
+### GitHub API Integration
+
+**Endpoints Used:**
+- **Latest Release**: `https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest`
+  - Extracts: tag_name, release name, published date
+- **Latest Commit**: `https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main`
+  - Extracts: commit SHA, message, author date
+
+**Network Handling:**
+- 30-second timeout for slow connections
+- Graceful error handling for offline scenarios
+- No external dependencies (uses curl and grep/sed)
+
+## 🔄 What's Changed
+
+### Documentation Updates
+
+**Updated Files:**
+- ✅ `CHANGELOG.md` - Added comprehensive v3.2.3 release notes
+- ✅ `README.md` - Updated version badge to v3.2.3, added `/version` command
+- ✅ `README_CN.md` - Updated version badge and command reference (Chinese)
+- ✅ `.claude/commands/version.md` - Complete implementation guide
+
+**Version References:**
+- All version badges updated from v3.2.2 to v3.2.3
+- "What's New" sections updated with v3.2.3 features
+- Command reference tables include `/version` command
+
+### Installation Scripts Enhancement
+
+**Future Enhancement** (for next release):
+- Installation scripts will automatically create `version.json` files
+- Track installation mode (local vs global)
+- Record installation timestamp
+- Support version tracking for both stable and development installations
+
+## 📋 Version Comparison Scenarios
+
+### Scenario 1: Up to Date
+```
+✅ You are on the latest stable version (3.2.3)
+```
+
+### Scenario 2: Upgrade Available
+```
+⬆️ A newer stable version is available: v3.2.4
+Your version: 3.2.3
+
+To upgrade:
+PowerShell: iex (iwr -useb https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.ps1)
+Bash: bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.sh)
+```
+
+### Scenario 3: Development Version
+```
+✨ You are running a development version (3.3.0-dev)
+This is newer than the latest stable release (v3.2.3)
+```
+
+## 🛠️ Technical Details
+
+### Implementation Highlights
+
+**Simple Bash Commands:**
+- No jq dependency required (uses grep/sed for JSON parsing)
+- Cross-platform compatible (Windows Git Bash, Linux, macOS)
+- Version comparison using `sort -V` for semantic versioning
+- Direct API access using curl with error suppression
+
+**Command Structure:**
+```bash
+# Check local version
+test -f ./.claude/version.json && cat ./.claude/version.json
+
+# Check global version
+test -f ~/.claude/version.json && cat ~/.claude/version.json
+
+# Fetch latest release (with timeout)
+curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null
+
+# Extract version
+grep -o '"tag_name": *"[^"]*"' | cut -d'"' -f4
+
+# Compare versions
+printf "%s\n%s" "3.2.2" "3.2.3" | sort -V | tail -n 1
+```
+
+## 📊 Benefits
+
+### User Experience
+- 🔍 **Quick version check** with single command
+- 📊 **Comprehensive information** display (local, global, stable, dev)
+- 🔄 **Automatic upgrade notifications** when new versions available
+- 📈 **Development version tracking** for cutting-edge features
+- 🌐 **GitHub integration** for latest updates
+
+### DevOps
+- 📁 **Version tracking** in both local and global installations
+- 🕐 **Installation timestamp** for audit trails
+- 🔀 **Support for both stable and development** branches
+- ⚡ **Fast execution** with 30-second network timeout
+- 🛡️ **Graceful error handling** for offline scenarios
+
+## 🔗 Related Commands
+
+- `/cli:cli-init` - Initialize CLI tool configurations
+- `/workflow:session:list` - List workflow sessions
+- `/update-memory-full` - Update project documentation
+
+## 📦 Installation
+
+### Fresh Installation
+
+**Windows (PowerShell):**
+```powershell
+iex (iwr -useb https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.ps1)
+```
+
+**Linux/macOS (Bash):**
+```bash
+bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.sh)
+```
+
+### Upgrade from v3.2.2
+
+Use the same installation commands above. The installer will automatically:
+1. Detect your existing installation
+2. Back up current files (if using `-BackupAll`)
+3. Update to v3.2.3
+4. Create/update `version.json` files
+
+## 🐛 Bug Fixes
+
+- Fixed commit message extraction to handle JSON escape sequences
+- Improved API endpoint from `/branches/main` to `/commits/main` for reliable commit info
+- Added 30-second timeout to all network calls for slow connections
+- Enhanced release name and published date extraction
+
+## 📚 Documentation
+
+### New Documentation
+- `.claude/commands/version.md` - Complete command implementation guide
+  - API endpoints and usage
+  - Timeout configuration
+  - Error handling scenarios
+  - Simple bash command examples
+
+### Updated Documentation
+- `CHANGELOG.md` - v3.2.3 release notes
+- `README.md` - Version badge and command reference
+- `README_CN.md` - Chinese version updates
+
+## 🙏 Credits
+
+This release includes contributions and improvements based on:
+- GitHub API integration for version detection
+- Cross-platform bash command compatibility
+- User feedback on installation and upgrade processes
+
+## 📝 Notes
+
+- **Backward Compatible**: All existing commands and workflows continue to work
+- **No Breaking Changes**: This is a minor release with new features only
+- **Optional Feature**: `/version` command is entirely optional, existing workflows unaffected
+
+## 🚀 What's Next
+
+**Planned for v3.2.4:**
+- Enhanced installation script to auto-create version.json
+- Version tracking in all installation modes
+- Automatic version detection during installation
+
+**Future Enhancements:**
+- Auto-update functionality (opt-in)
+- Version comparison in workflow sessions
+- Release notes display in CLI
+
+---
+
+**Full Changelog**: [v3.2.2...v3.2.3](https://github.com/catlog22/Claude-Code-Workflow/compare/v3.2.2...v3.2.3)
+
+**Installation:**
+```bash
+# One-line install (recommended)
+bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.sh)
+
+# Or use specific version tag
+git clone -b v3.2.3 https://github.com/catlog22/Claude-Code-Workflow.git
+```
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)

install-remote.ps1

@@ -1,16 +1,88 @@
 #!/usr/bin/env pwsh
-# Claude Code Workflow (CCW) - Remote Installation Script
+<#
-# One-liner remote installation for Claude Code Workflow system
+.SYNOPSIS
+    Claude Code Workflow (CCW) - Remote Installation Script
+
+.DESCRIPTION
+    One-liner remote installation for Claude Code Workflow system.
+    Downloads and installs CCW from GitHub with flexible version selection.
+
+.PARAMETER Version
+    Installation version type:
+    - "stable" (default): Latest stable release tag
+    - "latest": Latest main branch (development version)
+    - "branch": Install from specific branch
+
+.PARAMETER Tag
+    Specific release tag to install (e.g., "v3.2.0")
+    Only used when Version is "stable"
+
+.PARAMETER Branch
+    Branch name to install from (default: "main")
+    Only used when Version is "branch"
+
+.PARAMETER Global
+    Install to global user directory (~/.claude)
+
+.PARAMETER Directory
+    Install to custom directory
+
+.PARAMETER Force
+    Skip confirmation prompts
+
+.PARAMETER NoBackup
+    Skip backup of existing installation
+
+.PARAMETER NonInteractive
+    Run in non-interactive mode
+
+.PARAMETER BackupAll
+    Backup all files including git-ignored files
+
+.EXAMPLE
+    # Install latest stable release (recommended)
+    .\install-remote.ps1
+
+.EXAMPLE
+    # Install specific stable version
+    .\install-remote.ps1 -Version stable -Tag "v3.2.0"
+
+.EXAMPLE
+    # Install latest development version
+    .\install-remote.ps1 -Version latest
+
+.EXAMPLE
+    # Install from specific branch
+    .\install-remote.ps1 -Version branch -Branch "feature/new-feature"
+
+.EXAMPLE
+    # Install to global directory without prompts
+    .\install-remote.ps1 -Global -Force
+
+.LINK
+    https://github.com/catlog22/Claude-Code-Workflow
+#>
 
 [CmdletBinding()]
 param(
+    [ValidateSet("stable", "latest", "branch")]
+    [string]$Version = "stable",
+
+    [string]$Tag = "",
+
+    [string]$Branch = "main",
+
     [switch]$Global,
+
     [string]$Directory = "",
+
     [switch]$Force,
+
     [switch]$NoBackup,
+
     [switch]$NonInteractive,
-    [switch]$BackupAll,
+
-    [string]$Branch = "main"
+    [switch]$BackupAll
 )
 
 # Set encoding for proper Unicode support
@@ -26,7 +98,7 @@ if ($PSVersionTable.PSVersion.Major -ge 6) {
 
 # Script metadata
 $ScriptName = "Claude Code Workflow (CCW) Remote Installer"
-$Version = "2.1.1"
+$InstallerVersion = "2.2.0"
 
 # Colors for output
 $ColorSuccess = "Green"
@@ -43,7 +115,7 @@ function Write-ColorOutput {
 }
 
 function Show-Header {
-    Write-ColorOutput "==== $ScriptName v$Version ====" $ColorInfo
+    Write-ColorOutput "==== $ScriptName v$InstallerVersion ====" $ColorInfo
     Write-ColorOutput "========================================================" $ColorInfo
     Write-Host ""
 }
@@ -78,29 +150,70 @@ function Get-TempDirectory {
     return $tempDir
 }
 
+function Get-LatestRelease {
+    try {
+        $apiUrl = "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest"
+        $response = Invoke-RestMethod -Uri $apiUrl -UseBasicParsing
+        return $response.tag_name
+    } catch {
+        Write-ColorOutput "WARNING: Failed to fetch latest release, using 'main' branch" $ColorWarning
+        return $null
+    }
+}
+
 function Download-Repository {
     param(
         [string]$TempDir,
-        [string]$Branch = "main"
+        [string]$Version = "stable",
+        [string]$Branch = "main",
+        [string]$Tag = ""
     )
-    
+
     $repoUrl = "https://github.com/catlog22/Claude-Code-Workflow"
-    $zipUrl = "$repoUrl/archive/refs/heads/$Branch.zip"
+
+    # Determine download URL based on version type
+    if ($Version -eq "stable") {
+        # Download latest stable release
+        if ([string]::IsNullOrEmpty($Tag)) {
+            $latestTag = Get-LatestRelease
+            if ($latestTag) {
+                $Tag = $latestTag
+            } else {
+                # Fallback to main branch if API fails
+                $zipUrl = "$repoUrl/archive/refs/heads/main.zip"
+                $downloadType = "main branch (fallback)"
+            }
+        }
+
+        if (-not [string]::IsNullOrEmpty($Tag)) {
+            $zipUrl = "$repoUrl/archive/refs/tags/$Tag.zip"
+            $downloadType = "stable release $Tag"
+        }
+    } elseif ($Version -eq "latest") {
+        # Download latest main branch
+        $zipUrl = "$repoUrl/archive/refs/heads/main.zip"
+        $downloadType = "latest main branch"
+    } else {
+        # Download specific branch
+        $zipUrl = "$repoUrl/archive/refs/heads/$Branch.zip"
+        $downloadType = "branch $Branch"
+    }
+
     $zipPath = Join-Path $TempDir "repo.zip"
-    
+
     Write-ColorOutput "Downloading from GitHub..." $ColorInfo
     Write-ColorOutput "Source: $repoUrl" $ColorInfo
-    Write-ColorOutput "Branch: $Branch" $ColorInfo
+    Write-ColorOutput "Type: $downloadType" $ColorInfo
-    
+
     try {
         # Download with progress
         $progressPreference = $ProgressPreference
         $ProgressPreference = 'SilentlyContinue'
-        
+
         Invoke-WebRequest -Uri $zipUrl -OutFile $zipPath -UseBasicParsing
-        
+
         $ProgressPreference = $progressPreference
-        
+
         if (Test-Path $zipPath) {
             $fileSize = (Get-Item $zipPath).Length
             Write-ColorOutput "Download complete ($([math]::Round($fileSize/1024/1024, 2)) MB)" $ColorSuccess
@@ -145,23 +258,25 @@ function Extract-Repository {
 
 function Invoke-LocalInstaller {
     param(
-        [string]$RepoDir
+        [string]$RepoDir,
+        [string]$VersionInfo = "",
+        [string]$BranchInfo = ""
     )
-    
+
     $installerPath = Join-Path $RepoDir "Install-Claude.ps1"
-    
+
     if (-not (Test-Path $installerPath)) {
         Write-ColorOutput "ERROR: Install-Claude.ps1 not found" $ColorError
         return $false
     }
-    
+
     Write-ColorOutput "Running local installer..." $ColorInfo
     Write-Host ""
-    
+
     # Build parameters for local installer
     $params = @{}
     if ($Global) { $params["InstallMode"] = "Global" }
-    if ($Directory) { 
+    if ($Directory) {
         $params["InstallMode"] = "Custom"
         $params["TargetPath"] = $Directory
     }
@@ -169,11 +284,15 @@ function Invoke-LocalInstaller {
     if ($NoBackup) { $params["NoBackup"] = $NoBackup }
     if ($NonInteractive) { $params["NonInteractive"] = $NonInteractive }
     if ($BackupAll) { $params["BackupAll"] = $BackupAll }
-    
+
+    # Pass version and branch information
+    if ($VersionInfo) { $params["SourceVersion"] = $VersionInfo }
+    if ($BranchInfo) { $params["SourceBranch"] = $BranchInfo }
+
     try {
         # Change to repo directory and run installer
         Push-Location $RepoDir
-        
+
         if ($params.Count -gt 0) {
             $paramList = ($params.GetEnumerator() | ForEach-Object { "-$($_.Key) $($_.Value)" }) -join " "
             Write-ColorOutput "Executing: & `"$installerPath`" $paramList" $ColorInfo
@@ -182,7 +301,7 @@ function Invoke-LocalInstaller {
             Write-ColorOutput "Executing: & `"$installerPath`"" $ColorInfo
             & $installerPath
         }
-        
+
         Pop-Location
         return $true
     } catch {
@@ -225,29 +344,200 @@ function Wait-ForUserConfirmation {
     }
 }
 
+function Show-VersionMenu {
+    param(
+        [string]$LatestStableVersion = "Detecting...",
+        [string]$LatestStableDate = "",
+        [string]$LatestCommitId = "",
+        [string]$LatestCommitDate = ""
+    )
+
+    Write-Host ""
+    Write-ColorOutput "====================================================" $ColorInfo
+    Write-ColorOutput "            Version Selection Menu" $ColorInfo
+    Write-ColorOutput "====================================================" $ColorInfo
+    Write-Host ""
+
+    # Option 1: Latest Stable
+    Write-ColorOutput "1) Latest Stable Release (Recommended)" $ColorSuccess
+    if ($LatestStableVersion -ne "Detecting..." -and $LatestStableVersion -ne "Unknown") {
+        Write-Host "   |-- Version: $LatestStableVersion"
+        if ($LatestStableDate) {
+            Write-Host "   |-- Released: $LatestStableDate"
+        }
+        Write-Host "   \-- Production-ready"
+    } else {
+        Write-Host "   |-- Version: Auto-detected from GitHub"
+        Write-Host "   \-- Production-ready"
+    }
+    Write-Host ""
+
+    # Option 2: Latest Development
+    Write-ColorOutput "2) Latest Development Version" $ColorWarning
+    Write-Host "   |-- Branch: main"
+    if ($LatestCommitId -and $LatestCommitDate) {
+        Write-Host "   |-- Commit: $LatestCommitId"
+        Write-Host "   |-- Updated: $LatestCommitDate"
+    }
+    Write-Host "   |-- Cutting-edge features"
+    Write-Host "   \-- May contain experimental changes"
+    Write-Host ""
+
+    # Option 3: Specific Version
+    Write-ColorOutput "3) Specific Release Version" $ColorInfo
+    Write-Host "   |-- Install a specific tagged release"
+    Write-Host "   \-- Recent: v3.2.0, v3.1.0, v3.0.1"
+    Write-Host ""
+
+    Write-ColorOutput "====================================================" $ColorInfo
+    Write-Host ""
+}
+
+function Get-UserVersionChoice {
+    if ($NonInteractive -or $Force) {
+        # Non-interactive mode: use default stable version
+        return @{
+            Type = "stable"
+            Tag = $Tag
+            Branch = $Branch
+        }
+    }
+
+    # Detect latest stable version and commit info
+    Write-ColorOutput "Detecting latest release and commits..." $ColorInfo
+    $latestVersion = "Unknown"
+    $latestStableDate = ""
+    $latestCommitId = ""
+    $latestCommitDate = ""
+
+    try {
+        # Get latest release info
+        $apiUrl = "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest"
+        $response = Invoke-RestMethod -Uri $apiUrl -UseBasicParsing -TimeoutSec 5
+        $latestVersion = $response.tag_name
+
+        # Parse and format release date
+        if ($response.published_at) {
+            $publishDate = [DateTime]::Parse($response.published_at)
+            $latestStableDate = $publishDate.ToString("yyyy-MM-dd HH:mm UTC")
+        }
+
+        Write-ColorOutput "Latest stable: $latestVersion ($latestStableDate)" $ColorSuccess
+    } catch {
+        Write-ColorOutput "Could not detect latest release" $ColorWarning
+    }
+
+    try {
+        # Get latest commit info from main branch
+        $commitUrl = "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main"
+        $commitResponse = Invoke-RestMethod -Uri $commitUrl -UseBasicParsing -TimeoutSec 5
+        $latestCommitId = $commitResponse.sha.Substring(0, 7)
+
+        # Parse and format commit date
+        if ($commitResponse.commit.committer.date) {
+            $commitDate = [DateTime]::Parse($commitResponse.commit.committer.date)
+            $latestCommitDate = $commitDate.ToString("yyyy-MM-dd HH:mm UTC")
+        }
+
+        Write-ColorOutput "Latest commit: $latestCommitId ($latestCommitDate)" $ColorSuccess
+    } catch {
+        Write-ColorOutput "Could not detect latest commit" $ColorWarning
+    }
+
+    Show-VersionMenu -LatestStableVersion $latestVersion -LatestStableDate $latestStableDate -LatestCommitId $latestCommitId -LatestCommitDate $latestCommitDate
+
+    $choice = Read-Host "Select version to install (1-3, default: 1)"
+
+    switch ($choice) {
+        "2" {
+            Write-Host ""
+            Write-ColorOutput "✓ Selected: Latest Development Version (main branch)" $ColorSuccess
+            return @{
+                Type = "latest"
+                Tag = ""
+                Branch = "main"
+            }
+        }
+        "3" {
+            Write-Host ""
+            Write-ColorOutput "Available recent releases:" $ColorInfo
+            Write-Host "  v3.2.0, v3.1.0, v3.0.1, v3.0.0"
+            Write-Host ""
+            $tagInput = Read-Host "Enter version tag (e.g., v3.2.0)"
+
+            if ([string]::IsNullOrWhiteSpace($tagInput)) {
+                Write-ColorOutput "No tag specified, using latest stable" $ColorWarning
+                return @{
+                    Type = "stable"
+                    Tag = ""
+                    Branch = "main"
+                }
+            }
+
+            Write-ColorOutput "✓ Selected: Specific Version $tagInput" $ColorSuccess
+            return @{
+                Type = "stable"
+                Tag = $tagInput
+                Branch = "main"
+            }
+        }
+        default {
+            Write-Host ""
+            if ($latestVersion -ne "Unknown") {
+                Write-ColorOutput "✓ Selected: Latest Stable Release ($latestVersion)" $ColorSuccess
+            } else {
+                Write-ColorOutput "✓ Selected: Latest Stable Release (auto-detect)" $ColorSuccess
+            }
+            return @{
+                Type = "stable"
+                Tag = ""
+                Branch = "main"
+            }
+        }
+    }
+}
+
 function Main {
     Show-Header
-    
+
     Write-ColorOutput "This will download and install Claude Code Workflow System from GitHub." $ColorInfo
     Write-Host ""
-    
+
     # Test prerequisites
     Write-ColorOutput "Checking system requirements..." $ColorInfo
     if (-not (Test-Prerequisites)) {
         Wait-ForUserConfirmation "System check failed! Press any key to exit..." -ExitAfter
     }
-    
+
+    # Get version choice from user (interactive menu)
+    $versionChoice = Get-UserVersionChoice
+    $script:Version = $versionChoice.Type
+    $script:Tag = $versionChoice.Tag
+    $script:Branch = $versionChoice.Branch
+
+    # Determine version information for display
+    $versionInfo = switch ($Version) {
+        "stable" {
+            if ($Tag) { "Stable release: $Tag" }
+            else { "Latest stable release (auto-detected)" }
+        }
+        "latest" { "Latest main branch (development)" }
+        "branch" { "Custom branch: $Branch" }
+    }
+
     # Confirm installation
     if (-not $NonInteractive -and -not $Force) {
         Write-Host ""
-        Write-ColorOutput "SECURITY NOTE:" $ColorWarning
+        Write-ColorOutput "INSTALLATION DETAILS:" $ColorInfo
-        Write-Host "- This script will download and execute Claude Code Workflow from GitHub"
+        Write-Host "- Repository: https://github.com/catlog22/Claude-Code-Workflow"
-        Write-Host "- Repository: https://github.com/catlog22/Claude-Code-Workflow"  
+        Write-Host "- Version: $versionInfo"
-        Write-Host "- Branch: $Branch (latest stable version)"
         Write-Host "- Features: Intelligent workflow orchestration with multi-agent coordination"
+        Write-Host ""
+        Write-ColorOutput "SECURITY NOTE:" $ColorWarning
+        Write-Host "- This script will download and execute code from GitHub"
         Write-Host "- Please ensure you trust this source"
         Write-Host ""
-        
+
         $choice = Read-Host "Continue with installation? (y/N)"
         if ($choice -notmatch '^[Yy]') {
             Write-ColorOutput "Installation cancelled" $ColorWarning
@@ -258,26 +548,32 @@ function Main {
     # Create temp directory
     $tempDir = Get-TempDirectory
     Write-ColorOutput "Temporary directory: $tempDir" $ColorInfo
-    
+
     try {
         # Download repository
-        $zipPath = Download-Repository $tempDir $Branch
+        $zipPath = Download-Repository -TempDir $tempDir -Version $Version -Branch $Branch -Tag $Tag
         if (-not $zipPath) {
             throw "Download failed"
         }
-        
+
         # Extract repository
         $repoDir = Extract-Repository $zipPath $tempDir
         if (-not $repoDir) {
             throw "Extraction failed"
         }
-        
+
-        # Run local installer
+        # Determine version and branch information to pass
-        $success = Invoke-LocalInstaller $repoDir
+        $versionToPass = if ($Tag) { $Tag } else { "latest" }
+        $branchToPass = if ($Version -eq "branch") { $Branch } elseif ($Version -eq "latest") { "main" } elseif ($Tag) { $Tag } else { "main" }
+
+        Write-ColorOutput "Version info: $versionToPass (branch: $branchToPass)" $ColorInfo
+
+        # Run local installer with version information
+        $success = Invoke-LocalInstaller -RepoDir $repoDir -VersionInfo $versionToPass -BranchInfo $branchToPass
         if (-not $success) {
             throw "Installation script failed"
         }
-        
+
         Write-Host ""
         Write-ColorOutput "Remote installation completed successfully!" $ColorSuccess
         

install-remote.sh

@@ -6,9 +6,13 @@ set -e  # Exit on error
 
 # Script metadata
 SCRIPT_NAME="Claude Code Workflow (CCW) Remote Installer"
-VERSION="2.1.1"
+INSTALLER_VERSION="2.2.0"
 BRANCH="${BRANCH:-main}"
 
+# Version control
+VERSION_TYPE="${VERSION_TYPE:-stable}"  # stable, latest, branch
+TAG_VERSION=""
+
 # Colors for output
 COLOR_RESET='\033[0m'
 COLOR_SUCCESS='\033[0;32m'
@@ -32,15 +36,15 @@ function write_color() {
 }
 
 function show_header() {
-    write_color "==== $SCRIPT_NAME v$VERSION ====" "$COLOR_INFO"
+    write_color "==== $SCRIPT_NAME v$INSTALLER_VERSION ====" "$COLOR_INFO"
     write_color "========================================================" "$COLOR_INFO"
     echo ""
 }
 
 function test_prerequisites() {
     # Test bash version
-    if [ "${BASH_VERSINFO[0]}" -lt 4 ]; then
+    if [ "${BASH_VERSINFO[0]}" -lt 2 ]; then
-        write_color "ERROR: Bash 4.0 or higher is required" "$COLOR_ERROR"
+        write_color "ERROR: Bash 2.0 or higher is required" "$COLOR_ERROR"
         write_color "Current version: ${BASH_VERSION}" "$COLOR_ERROR"
         return 1
     fi
@@ -72,17 +76,80 @@ function get_temp_directory() {
     echo "$temp_dir"
 }
 
+function get_latest_release() {
+    local api_url="https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest"
+
+    if command -v jq &> /dev/null; then
+        # Use jq if available
+        local tag
+        tag=$(curl -fsSL "$api_url" 2>/dev/null | jq -r '.tag_name' 2>/dev/null)
+        if [ -n "$tag" ] && [ "$tag" != "null" ]; then
+            echo "$tag"
+            return 0
+        fi
+    else
+        # Fallback: parse JSON with grep/sed
+        local tag
+        tag=$(curl -fsSL "$api_url" 2>/dev/null | grep -o '"tag_name":\s*"[^"]*"' | sed 's/"tag_name":\s*"\([^"]*\)"/\1/')
+        if [ -n "$tag" ]; then
+            echo "$tag"
+            return 0
+        fi
+    fi
+
+    write_color "WARNING: Failed to fetch latest release, using 'main' branch" "$COLOR_WARNING" >&2
+    return 1
+}
+
 function download_repository() {
     local temp_dir="$1"
-    local branch="${2:-main}"
+    local version_type="${2:-stable}"
+    local branch="${3:-main}"
+    local tag="${4:-}"
     local repo_url="https://github.com/catlog22/Claude-Code-Workflow"
-    local zip_url="${repo_url}/archive/refs/heads/${branch}.zip"
+    local zip_url=""
+    local download_type=""
+
+    # Determine download URL based on version type
+    case "$version_type" in
+        stable)
+            # Download latest stable release
+            if [ -z "$tag" ]; then
+                tag=$(get_latest_release)
+                if [ -z "$tag" ]; then
+                    # Fallback to main branch if API fails
+                    zip_url="${repo_url}/archive/refs/heads/main.zip"
+                    download_type="main branch (fallback)"
+                else
+                    zip_url="${repo_url}/archive/refs/tags/${tag}.zip"
+                    download_type="stable release $tag"
+                fi
+            else
+                zip_url="${repo_url}/archive/refs/tags/${tag}.zip"
+                download_type="stable release $tag"
+            fi
+            ;;
+        latest)
+            # Download latest main branch
+            zip_url="${repo_url}/archive/refs/heads/main.zip"
+            download_type="latest main branch"
+            ;;
+        branch)
+            # Download specific branch
+            zip_url="${repo_url}/archive/refs/heads/${branch}.zip"
+            download_type="branch $branch"
+            ;;
+        *)
+            write_color "ERROR: Invalid version type: $version_type" "$COLOR_ERROR" >&2
+            return 1
+            ;;
+    esac
+
     local zip_path="${temp_dir}/repo.zip"
 
     write_color "Downloading from GitHub..." "$COLOR_INFO" >&2
     write_color "Source: $repo_url" "$COLOR_INFO" >&2
-    write_color "Branch: $branch" "$COLOR_INFO" >&2
+    write_color "Type: $download_type" "$COLOR_INFO" >&2
-    write_color "URL: $zip_url" "$COLOR_INFO" >&2
 
     # Download with curl
     if curl -fsSL -o "$zip_path" "$zip_url" 2>&1 >&2; then
@@ -217,6 +284,23 @@ function wait_for_user() {
 function parse_arguments() {
     while [[ $# -gt 0 ]]; do
         case "$1" in
+            --version)
+                VERSION_TYPE="$2"
+                if [[ ! "$VERSION_TYPE" =~ ^(stable|latest|branch)$ ]]; then
+                    write_color "ERROR: Invalid version type: $VERSION_TYPE" "$COLOR_ERROR"
+                    write_color "Valid options: stable, latest, branch" "$COLOR_ERROR"
+                    exit 1
+                fi
+                shift 2
+                ;;
+            --tag)
+                TAG_VERSION="$2"
+                shift 2
+                ;;
+            --branch)
+                BRANCH="$2"
+                shift 2
+                ;;
             --global)
                 INSTALL_GLOBAL=true
                 shift
@@ -241,10 +325,6 @@ function parse_arguments() {
                 BACKUP_ALL=true
                 shift
                 ;;
-            --branch)
-                BRANCH="$2"
-                shift 2
-                ;;
             --help)
                 show_help
                 exit 0
@@ -260,33 +340,208 @@ function parse_arguments() {
 
 function show_help() {
     cat << EOF
-$SCRIPT_NAME v$VERSION
+$SCRIPT_NAME v$INSTALLER_VERSION
 
 Usage: $0 [OPTIONS]
 
-Options:
+Version Options:
+    --version TYPE        Version type: stable (default), latest, or branch
+    --tag TAG             Specific release tag (e.g., v3.2.0) - for stable version
+    --branch BRANCH       Branch name (default: main) - for branch version
+
+Installation Options:
     --global              Install to global user directory (~/.claude)
     --directory DIR       Install to custom directory
     --force               Force installation without prompts
     --no-backup           Skip backup creation
     --non-interactive     Non-interactive mode (no prompts)
     --backup-all          Backup all files before installation
-    --branch BRANCH       Specify GitHub branch (default: main)
     --help                Show this help message
 
 Examples:
-    # Interactive installation
+    # Install latest stable release (recommended)
     $0
 
+    # Install specific stable version
+    $0 --version stable --tag v3.2.0
+
+    # Install latest development version
+    $0 --version latest
+
+    # Install from specific branch
+    $0 --version branch --branch feature/new-feature
+
     # Global installation without prompts
     $0 --global --non-interactive
 
     # Custom directory installation
     $0 --directory /opt/claude-code-workflow
 
+Repository: https://github.com/catlog22/Claude-Code-Workflow
+
 EOF
 }
 
+function show_version_menu() {
+    local latest_version="$1"
+    local latest_date="$2"
+    local commit_id="$3"
+    local commit_date="$4"
+
+    echo ""
+    write_color "====================================================" "$COLOR_INFO"
+    write_color "            Version Selection Menu" "$COLOR_INFO"
+    write_color "====================================================" "$COLOR_INFO"
+    echo ""
+
+    # Option 1: Latest Stable
+    write_color "1) Latest Stable Release (Recommended)" "$COLOR_SUCCESS"
+    if [ -n "$latest_version" ] && [ "$latest_version" != "Unknown" ]; then
+        echo "   |-- Version: $latest_version"
+        if [ -n "$latest_date" ]; then
+            echo "   |-- Released: $latest_date"
+        fi
+        echo "   \-- Production-ready"
+    else
+        echo "   |-- Version: Auto-detected from GitHub"
+        echo "   \-- Production-ready"
+    fi
+    echo ""
+
+    # Option 2: Latest Development
+    write_color "2) Latest Development Version" "$COLOR_WARNING"
+    echo "   |-- Branch: main"
+    if [ -n "$commit_id" ] && [ -n "$commit_date" ]; then
+        echo "   |-- Commit: $commit_id"
+        echo "   |-- Updated: $commit_date"
+    fi
+    echo "   |-- Cutting-edge features"
+    echo "   \-- May contain experimental changes"
+    echo ""
+
+    # Option 3: Specific Version
+    write_color "3) Specific Release Version" "$COLOR_INFO"
+    echo "   |-- Install a specific tagged release"
+    echo "   \-- Recent: v3.2.0, v3.1.0, v3.0.1"
+    echo ""
+
+    write_color "====================================================" "$COLOR_INFO"
+    echo ""
+}
+
+function get_user_version_choice() {
+    if [ "$NON_INTERACTIVE" = true ] || [ "$FORCE" = true ]; then
+        # Non-interactive mode: use default stable version
+        echo "stable"
+        return 0
+    fi
+
+    # Detect latest stable version and commit info
+    write_color "Detecting latest release and commits..." "$COLOR_INFO"
+    local latest_version="Unknown"
+    local latest_date=""
+    local commit_id=""
+    local commit_date=""
+
+    # Get latest release info
+    local release_data
+    release_data=$(curl -fsSL --connect-timeout 5 "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null)
+
+    if [ -n "$release_data" ]; then
+        if command -v jq &> /dev/null; then
+            latest_version=$(echo "$release_data" | jq -r '.tag_name' 2>/dev/null)
+            local published_at=$(echo "$release_data" | jq -r '.published_at' 2>/dev/null)
+            if [ -n "$published_at" ] && [ "$published_at" != "null" ]; then
+                # Format: 2025-10-02T04:27:21Z -> 2025-10-02 04:27 UTC
+                latest_date=$(echo "$published_at" | sed 's/T/ /' | sed 's/Z/ UTC/' | cut -d'.' -f1)
+            fi
+        else
+            latest_version=$(echo "$release_data" | grep -o '"tag_name":\s*"[^"]*"' | sed 's/"tag_name":\s*"\([^"]*\)"/\1/')
+            local published_at=$(echo "$release_data" | grep -o '"published_at":\s*"[^"]*"' | sed 's/"published_at":\s*"\([^"]*\)"/\1/')
+            if [ -n "$published_at" ]; then
+                latest_date=$(echo "$published_at" | sed 's/T/ /' | sed 's/Z/ UTC/' | cut -d'.' -f1)
+            fi
+        fi
+    fi
+
+    if [ -n "$latest_version" ] && [ "$latest_version" != "null" ] && [ "$latest_version" != "Unknown" ]; then
+        write_color "Latest stable: $latest_version ($latest_date)" "$COLOR_SUCCESS"
+    else
+        latest_version="Unknown"
+        write_color "Could not detect latest release" "$COLOR_WARNING"
+    fi
+
+    # Get latest commit info
+    local commit_data
+    commit_data=$(curl -fsSL --connect-timeout 5 "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null)
+
+    if [ -n "$commit_data" ]; then
+        if command -v jq &> /dev/null; then
+            commit_id=$(echo "$commit_data" | jq -r '.sha' 2>/dev/null | cut -c1-7)
+            local committer_date=$(echo "$commit_data" | jq -r '.commit.committer.date' 2>/dev/null)
+            if [ -n "$committer_date" ] && [ "$committer_date" != "null" ]; then
+                commit_date=$(echo "$committer_date" | sed 's/T/ /' | sed 's/Z/ UTC/' | cut -d'.' -f1)
+            fi
+        else
+            commit_id=$(echo "$commit_data" | grep -o '"sha":\s*"[^"]*"' | head -1 | sed 's/"sha":\s*"\([^"]*\)"/\1/' | cut -c1-7)
+            local committer_date=$(echo "$commit_data" | grep -o '"date":\s*"[^"]*"' | head -1 | sed 's/"date":\s*"\([^"]*\)"/\1/')
+            if [ -n "$committer_date" ]; then
+                commit_date=$(echo "$committer_date" | sed 's/T/ /' | sed 's/Z/ UTC/' | cut -d'.' -f1)
+            fi
+        fi
+    fi
+
+    if [ -n "$commit_id" ] && [ -n "$commit_date" ]; then
+        write_color "Latest commit: $commit_id ($commit_date)" "$COLOR_SUCCESS"
+    else
+        write_color "Could not detect latest commit" "$COLOR_WARNING"
+    fi
+
+    show_version_menu "$latest_version" "$latest_date" "$commit_id" "$commit_date"
+
+    read -p "Select version to install (1-3, default: 1): " choice
+
+    case "$choice" in
+        2)
+            echo ""
+            write_color "✓ Selected: Latest Development Version (main branch)" "$COLOR_SUCCESS"
+            VERSION_TYPE="latest"
+            TAG_VERSION=""
+            BRANCH="main"
+            ;;
+        3)
+            echo ""
+            write_color "Available recent releases:" "$COLOR_INFO"
+            echo "  v3.2.0, v3.1.0, v3.0.1, v3.0.0"
+            echo ""
+            read -p "Enter version tag (e.g., v3.2.0): " tag_input
+
+            if [ -z "$tag_input" ]; then
+                write_color "⚠ No tag specified, using latest stable" "$COLOR_WARNING"
+                VERSION_TYPE="stable"
+                TAG_VERSION=""
+            else
+                echo ""
+                write_color "✓ Selected: Specific Version $tag_input" "$COLOR_SUCCESS"
+                VERSION_TYPE="stable"
+                TAG_VERSION="$tag_input"
+            fi
+            BRANCH="main"
+            ;;
+        *)
+            echo ""
+            if [ "$latest_version" != "Unknown" ]; then
+                write_color "✓ Selected: Latest Stable Release ($latest_version)" "$COLOR_SUCCESS"
+            else
+                write_color "✓ Selected: Latest Stable Release (auto-detect)" "$COLOR_SUCCESS"
+            fi
+            VERSION_TYPE="stable"
+            TAG_VERSION=""
+            BRANCH="main"
+            ;;
+    esac
+}
+
 function main() {
     show_header
 
@@ -300,14 +555,37 @@ function main() {
         exit 1
     fi
 
+    # Get version choice from user (interactive menu)
+    get_user_version_choice
+
+    # Determine version information for display
+    local version_info=""
+    case "$VERSION_TYPE" in
+        stable)
+            if [ -n "$TAG_VERSION" ]; then
+                version_info="Stable release: $TAG_VERSION"
+            else
+                version_info="Latest stable release (auto-detected)"
+            fi
+            ;;
+        latest)
+            version_info="Latest main branch (development)"
+            ;;
+        branch)
+            version_info="Custom branch: $BRANCH"
+            ;;
+    esac
+
     # Confirm installation
     if [ "$NON_INTERACTIVE" != true ] && [ "$FORCE" != true ]; then
         echo ""
-        write_color "SECURITY NOTE:" "$COLOR_WARNING"
+        write_color "INSTALLATION DETAILS:" "$COLOR_INFO"
-        echo "- This script will download and execute Claude Code Workflow from GitHub"
         echo "- Repository: https://github.com/catlog22/Claude-Code-Workflow"
-        echo "- Branch: $BRANCH (latest stable version)"
+        echo "- Version: $version_info"
         echo "- Features: Intelligent workflow orchestration with multi-agent coordination"
+        echo ""
+        write_color "SECURITY NOTE:" "$COLOR_WARNING"
+        echo "- This script will download and execute code from GitHub"
         echo "- Please ensure you trust this source"
         echo ""
 
@@ -328,7 +606,7 @@ function main() {
     # Download repository
     local zip_path
     write_color "Starting download process..." "$COLOR_INFO"
-    zip_path=$(download_repository "$temp_dir" "$BRANCH")
+    zip_path=$(download_repository "$temp_dir" "$VERSION_TYPE" "$BRANCH" "$TAG_VERSION")
     local download_status=$?
 
     if [ $download_status -eq 0 ] && [ -n "$zip_path" ] && [ -f "$zip_path" ]; then