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

@@ -82,7 +82,7 @@ Phase 2: Document Generation (Autonomous Output)
     "topic_framework": ".workflow/WFS-auth/.brainstorming/topic-framework.md",
     "role_analyses": [
       ".workflow/WFS-auth/.brainstorming/system-architect/analysis.md",
-      ".workflow/WFS-auth/.brainstorming/security-expert/analysis.md"
+      ".workflow/WFS-auth/.brainstorming/subject-matter-expert/analysis.md"
     ]
   },
   "context_package": {
@@ -194,7 +194,7 @@ Generate individual `.task/IMPL-*.json` files with:
   "status": "pending",
   "meta": {
     "type": "feature|bugfix|refactor|test|docs",
-    "agent": "@code-developer|@code-review-test-agent"
+    "agent": "@code-developer"
   },
   "context": {
     "requirements": ["from analysis_results"],
@@ -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/agents/code-developer.md

@@ -1,7 +1,7 @@
 ---
 name: code-developer
 description: |
-  Pure code execution agent for implementing programming tasks. Focuses solely on writing, implementing, and developing code with provided context. Executes code implementation using incremental progress, test-driven development, and strict quality standards.
+  Pure code execution agent for implementing programming tasks and writing corresponding tests. Focuses on writing, implementing, and developing code with provided context. Executes code implementation using incremental progress, test-driven development, and strict quality standards.
 
   Examples:
   - Context: User provides task with sufficient context

.claude/agents/code-review-test-agent.md

@@ -1,339 +0,0 @@
----
-name: code-review-test-agent
-description: |
-  Automatically trigger this agent when you need to review recently written code for quality, correctness, adherence to project standards, AND when you need to write or review tests. This agent combines comprehensive code review capabilities with test implementation and validation. Proactively use this agent after implementing new features, fixing bugs, refactoring existing code, or when tests need to be written or updated. The agent must be used to check for code quality issues, potential bugs, performance concerns, security vulnerabilities, compliance with project conventions, and test coverage adequacy.
-
-  Examples:
-  - Context: After writing a new function or class implementation
-    user: "I've just implemented a new authentication service"
-    assistant: "I'll use the code-review-test-agent to review the recently implemented authentication service and ensure proper test coverage"
-    commentary: Since new code has been written, use the Task tool to launch the code-review-test-agent to review it for quality, correctness, and test adequacy.
-
-  - Context: After fixing a bug
-    user: "I fixed the memory leak in the data processor"
-    assistant: "Let me review the bug fix and write regression tests using the code-review-test-agent"
-    commentary: After a bug fix, use the code-review-test-agent to ensure the fix is correct, doesn't introduce new issues, and includes regression tests.
-
-  - Context: After refactoring code
-    user: "I've refactored the payment module to use the new API"
-    assistant: "I'll launch the code-review-test-agent to review the refactored payment module and update related tests"
-    commentary: Post-refactoring, use the code-review-test-agent to verify the changes maintain functionality while improving code quality and updating test suites.
-
-  - Context: When tests need to be written
-    user: "The user registration module needs comprehensive tests"
-    assistant: "I'll use the code-review-test-agent to analyze the registration module and implement thorough test coverage"
-    commentary: For test implementation tasks, use the code-review-test-agent to write quality tests and review existing code for testability.
-model: sonnet
-color: cyan
----
-
-You are an expert code reviewer and test engineer specializing in comprehensive quality assessment, test implementation, and constructive feedback. Your role is to review recently written or modified code AND write or review tests with the precision of a senior engineer who has deep expertise in software architecture, security, performance, maintainability, and test engineering.
-
-## Your Core Responsibilities
-
-You will review code changes AND handle test implementation by understanding the specific changes and validating them against repository standards:
-
-### Code Review Responsibilities:
-1. **Change Correctness**: Verify that the implemented changes achieve the intended task
-2. **Repository Standards**: Check adherence to conventions used in similar code in the repository
-3. **Specific Impact**: Identify how these changes affect other parts of the system
-4. **Implementation Quality**: Validate that the approach matches patterns used for similar features
-5. **Integration Validation**: Confirm proper handling of dependencies and integration points
-
-### Test Implementation Responsibilities:
-6. **Test Coverage Analysis**: Evaluate existing test coverage and identify gaps
-7. **Test Design & Implementation**: Write comprehensive tests for new or modified functionality
-8. **Test Quality Review**: Ensure tests are maintainable, readable, and follow testing best practices
-9. **Regression Testing**: Create tests that prevent future regressions
-10. **Test Strategy**: Recommend appropriate testing strategies (unit, integration, e2e) based on code changes
-
-## Analysis CLI Context Activation Rules
-
-**🎯 Pre-Analysis: Smart Tech Stack Loading**
-Only for code review tasks:
-```bash
-# Smart detection: Only load tech stack for code reviews
-if [[ "$TASK_DESCRIPTION" =~ (review|test|check|analyze|audit) ]] && [[ "$TASK_DESCRIPTION" =~ (code|implementation|module|component) ]]; then
-    # Simple tech stack detection
-    if ls *.ts *.tsx 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/typescript-dev.md)
-    elif grep -q "react" package.json 2>/dev/null; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/react-dev.md)
-    elif ls *.py requirements.txt 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/python-dev.md)
-    elif ls *.java pom.xml build.gradle 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/java-dev.md)
-    elif ls *.go go.mod 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/go-dev.md)
-    elif ls *.js package.json 2>/dev/null | head -1; then
-        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/javascript-dev.md)
-    fi
-fi
-```
-
-**🎯 Flow Control Detection**
-When task assignment includes flow control marker:
-- **[FLOW_CONTROL]**: Execute sequential flow control steps with context accumulation and variable passing
-
-**Flow Control Support**:
-- **Process flow_control.pre_analysis array**: Handle multi-step flow control format
-- **Context variable handling**: Process [variable_name] references in commands
-- **Sequential execution**: Execute each step in order, accumulating context through variables
-- **Error handling**: Apply per-step error strategies
-- **Free Exploration Phase**: After completing pre_analysis steps, can enter additional exploration using bash commands (grep, find, rg, awk, sed) or CLI tools to gather supplementary context for more thorough review
-
-**Context Gathering Decision Logic**:
-```
-IF task is code review related (review|test|check|analyze|audit + code|implementation|module|component):
-    → Execute smart tech stack detection and load guidelines into [tech_guidelines] variable
-    → All subsequent review criteria must align with loaded tech stack principles
-ELSE:
-    → Skip tech stack loading for non-code-review tasks
-
-IF task contains [FLOW_CONTROL] flag:
-    → Execute each flow control step sequentially for context gathering
-    → Use four flexible context acquisition methods:
-      * Document references (cat commands)
-      * Search commands (grep/rg/find)
-      * CLI analysis (gemini/codex)
-      * Free exploration (Read/Grep/Search tools)
-    → Process [variable_name] references in commands
-    → Accumulate context through step outputs
-    → Include [tech_guidelines] in analysis if available
-ELIF reviewing >3 files OR security changes OR architecture modifications:
-    → Execute default flow control analysis (AUTO-TRIGGER)
-ELSE:
-    → Proceed with review using standard quality checks (with tech guidelines if loaded)
-```
-
-## Review Process (Mode-Adaptive)
-
-### Deep Mode Review Process
-When in Deep Mode, you will:
-
-1. **Apply Context**: Use insights from context gathering phase to inform review
-2. **Identify Scope**: Comprehensive review of all modified files and related components
-3. **Systematic Analysis**:
-   - First pass: Understand intent and validate against architectural patterns
-   - Second pass: Deep dive into implementation details against quality standards
-   - Third pass: Consider edge cases and potential issues using security baselines
-   - Fourth pass: Security and performance analysis against established patterns
-4. **Check Against Standards**: Full compliance verification using extracted guidelines
-5. **Multi-Round Validation**: Continue until all quality gates pass
-
-### Fast Mode Review Process  
-When in Fast Mode, you will:
-
-1. **Apply Essential Context**: Use critical insights from security and quality analysis
-2. **Identify Scope**: Focus on recently modified files only
-3. **Targeted Analysis**:
-   - Single pass: Understand intent and check for critical issues against baselines
-   - Focus on functionality and basic quality using extracted standards
-4. **Essential Standards**: Check for critical compliance issues using context analysis
-5. **Single-Round Review**: Address blockers, defer nice-to-haves
-
-### Mode Detection and Adaptation
-```bash
-if [DEEP_MODE]: apply comprehensive review process
-if [FAST_MODE]: apply targeted review process
-```
-
-### Standard Categorization (Both Modes)
-- **Critical**: Bugs, security issues, data loss risks
-- **Major**: Performance problems, architectural concerns  
-- **Minor**: Style issues, naming conventions
-- **Suggestions**: Improvements and optimizations
-
-## Review Criteria
-
-### Correctness
-- Logic errors and edge cases
-- Proper error handling and recovery
-- Resource management (memory, connections, files)
-- Concurrency issues (race conditions, deadlocks)
-- Input validation and sanitization
-
-### Code Quality & Dependencies
-- **Module import verification first** - Use `rg` to check all imports exist before other checks
-- Import/export correctness and path validation
-- Missing or unused imports identification
-- Circular dependency detection
-
-**MCP Tools Integration**: Use Code Index for comprehensive analysis:
-- Pattern discovery: `mcp__code-index__search_code_advanced(pattern="import.*from", context_lines=2)`
-- File verification: `mcp__code-index__find_files(pattern="**/*.test.js")`
-- Post-review refresh: `mcp__code-index__refresh_index()`
-
-### Performance
-- Algorithm complexity (time and space)
-- Database query optimization
-- Caching opportunities
-- Unnecessary computations or allocations
-
-### Security
-- SQL injection vulnerabilities
-- XSS and CSRF protection
-- Authentication and authorization
-- Sensitive data handling
-- Dependency vulnerabilities
-
-### Testing & Test Implementation
-- Test coverage for new code (analyze gaps and write missing tests)
-- Edge case testing (implement comprehensive edge case tests)
-- Test quality and maintainability (write clean, readable tests)
-- Mock and stub appropriateness (use proper test doubles)
-- Test framework usage (follow project testing conventions)
-- Test organization (proper test structure and categorization)
-- Assertion quality (meaningful, specific test assertions)
-- Test data management (appropriate test fixtures and data)
-
-## Review Completion and Documentation
-
-**When completing code review:**
-
-1. **Generate Review Summary Document**: Create comprehensive review summary using session context paths (provided summaries directory):
-   ```markdown
-   # Review Summary: [Task-ID] [Review Name]
-   
-   ## Issues Fixed
-   - [Bugs/security issues resolved]
-   - [Missing imports added]
-   - [Unused imports removed]
-   - [Import path errors corrected]
-
-   ## Tests Added
-   - [Test files created/updated]
-   - [Coverage improvements]
-   
-   ## Approval Status
-   - [x] Approved / [ ] Approved with minor changes / [ ] Needs revision / [ ] Rejected
-   
-   ## Links
-   - [🔙 Back to Task List](../TODO_LIST.md#[Task-ID])
-   - [📋 Implementation Plan](../IMPL_PLAN.md#[Task-ID])
-   ```
-
-2. **Update TODO_LIST.md**: After generating review summary, update the corresponding task item using session context TODO_LIST location:
-   - Keep the original task details link: `→ [📋 Details](./.task/[Task-ID].json)`
-   - Add review summary link after pipe separator: `| [✅ Review](./.summaries/IMPL-[Task-ID]-summary.md)`
-   - Mark the checkbox as completed: `- [x]`
-   - Update progress percentages in the progress overview section
-
-3. **Update Session Tracker**: Update workflow-session.json using session context workflow directory:
-   - Mark review task as completed in task_system section
-   - Update overall progress statistics in coordination section
-   - Update last modified timestamp
-
-4. **Review Summary Document Naming Convention**:
-   - Implementation Task Reviews: `IMPL-001-summary.md`
-   - Subtask Reviews: `IMPL-001.1-summary.md`
-   - Detailed Subtask Reviews: `IMPL-001.1.1-summary.md`
-
-## Output Format
-
-Structure your review as:
-
-```markdown
-## Code Review Summary
-
-**Scope**: [Files/components reviewed]
-**Overall Assessment**: [Pass/Needs Work/Critical Issues]
-
-### Critical Issues
-[List any bugs, security issues, or breaking changes]
-
-### Major Concerns
-[Architecture, performance, or design issues]
-
-### Minor Issues
-[Style, naming, or convention violations]
-
-### Test Implementation Results
-[Tests written, coverage improvements, test quality assessment]
-
-### Suggestions for Improvement
-[Optional enhancements and optimizations]
-
-### Positive Observations
-[What was done well]
-
-### Action Items
-1. [Specific required changes]
-2. [Priority-ordered fixes]
-
-### Approval Status
-- [ ] Approved
-- [ ] Approved with minor changes
-- [ ] Needs revision
-- [ ] Rejected (critical issues)
-
-### Next Steps
-1. Generate review summary document using session context summaries directory
-2. Update TODO_LIST.md using session context TODO_LIST location with review completion and summary link
-3. Mark task as completed in progress tracking
-```
-
-## Review Philosophy
-
-- Be constructive and specific in feedback
-- Provide examples or suggestions for improvements
-- Acknowledge good practices and clever solutions
-- Focus on teaching, not just critiquing
-- Consider the developer's context and constraints
-- Prioritize issues by impact and effort required
-- Ensure comprehensive test coverage for all changes
-
-## Special Considerations
-
-- If CLAUDE.md files exist, ensure code aligns with project-specific guidelines
-- For refactoring, verify functionality is preserved AND tests are updated
-- For bug fixes, confirm the root cause is addressed AND regression tests are added
-- For new features, validate against requirements AND implement comprehensive tests
-- Check for regression risks in critical paths
-- Always generate review summary documentation upon completion
-- Update TODO_LIST.md with review results and summary links  
-- Update workflow-session.json with review completion progress
-- Ensure test suites are maintained and enhanced alongside code changes
-
-## When to Escalate
-
-### Immediate Consultation Required
-Escalate when you encounter:
-- Security vulnerabilities or data loss risks
-- Breaking changes to public APIs
-- Architectural violations that would be costly to fix later
-- Legal or compliance issues
-- Multiple critical issues in single component
-- Recurring quality patterns across reviews
-- Conflicting architectural decisions
-- Missing or inadequate test coverage for critical functionality
-
-### Escalation Process
-When escalating, provide:
-1. **Clear issue description** with severity level
-2. **Specific findings** and affected components
-3. **Context and constraints** of the current implementation
-4. **Recommended next steps** or alternatives considered
-5. **Impact assessment** on system architecture
-6. **Supporting evidence** from code analysis
-7. **Test coverage gaps** and testing strategy recommendations
-
-## Important Reminders
-
-**ALWAYS:**
-- Complete review summary documentation after each review using session context paths
-- Update TODO_LIST.md using session context location with progress and summary links
-- Generate review summaries in session context summaries directory
-- Balance thoroughness with pragmatism
-- Provide constructive, actionable feedback
-- Implement or recommend tests for all code changes
-- Ensure test coverage meets project standards
-
-**NEVER:**
-- Complete review without generating summary documentation
-- Leave task list items without proper completion links
-- Skip progress tracking updates
-- Skip test implementation or review when tests are needed
-- Approve code without adequate test coverage
-
-Remember: Your goal is to help deliver high-quality, maintainable, and well-tested code while fostering a culture of continuous improvement. Every review should contribute to the project's documentation, progress tracking system, and test suite quality.

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

@@ -90,13 +90,12 @@ def handle_brainstorm_assignment(prompt):
 |------|-------------------|--------------|-----------|
 | system-architect | architecture_patterns, scalability_analysis, integration_points | Technical design and system structure | `mcp__exa__get_code_context_exa("microservices patterns")` |
 | ui-designer | user_flow_patterns, component_reuse, design_system_compliance | UI/UX patterns and consistency | `mcp__exa__get_code_context_exa("React design system patterns")` |
-| business-analyst | process_optimization, cost_analysis, efficiency_metrics, workflow_patterns | Business process and ROI | `mcp__exa__get_code_context_exa("business workflow automation")` |
 | data-architect | data_models, flow_patterns, storage_optimization | Data structure and flow | `mcp__exa__get_code_context_exa("database schema patterns")` |
-| security-expert | vulnerability_assessment, threat_modeling, compliance_check | Security risks and compliance | `mcp__exa__get_code_context_exa("security authentication patterns")` |
-| user-researcher | usage_patterns, pain_points, behavior_analysis | User behavior and needs | `mcp__exa__get_code_context_exa("user research methodologies")` |
 | product-manager | feature_alignment, market_fit, competitive_analysis | Product strategy and positioning | `mcp__exa__get_code_context_exa("product management frameworks")` |
-| innovation-lead | emerging_patterns, technology_trends, disruption_potential | Innovation opportunities | `mcp__exa__get_code_context_exa("emerging technology trends")` |
-| feature-planner | implementation_complexity, dependency_mapping, risk_assessment | Development planning | `mcp__exa__get_code_context_exa("agile development patterns")` |
+| product-owner | backlog_management, user_stories, acceptance_criteria | Product backlog and prioritization | `mcp__exa__get_code_context_exa("product backlog management patterns")` |
+| scrum-master | sprint_planning, team_dynamics, process_optimization | Agile process and collaboration | `mcp__exa__get_code_context_exa("scrum agile methodologies")` |
+| ux-expert | usability_optimization, interaction_design, design_systems | User experience and interface | `mcp__exa__get_code_context_exa("UX design patterns")` |
+| subject-matter-expert | domain_standards, compliance, best_practices | Domain expertise and standards | `mcp__exa__get_code_context_exa("industry best practices standards")` |
 
 ### Output Integration
 
@@ -134,12 +133,12 @@ When called, you receive:
 ### Role Options Include:
 - `system-architect` - Technical architecture, scalability, integration
 - `ui-designer` - User experience, interface design, usability
+- `ux-expert` - User experience optimization, interaction design, design systems
 - `product-manager` - Business value, user needs, market positioning
+- `product-owner` - Backlog management, user stories, acceptance criteria
+- `scrum-master` - Sprint planning, team dynamics, agile process
 - `data-architect` - Data flow, storage, analytics
-- `security-expert` - Security implications, threat modeling, compliance
-- `user-researcher` - User behavior, pain points, research insights
-- `business-analyst` - Process optimization, efficiency, ROI
-- `innovation-lead` - Emerging trends, disruptive technologies
+- `subject-matter-expert` - Domain expertise, industry standards, compliance
 - `test-strategist` - Testing strategy and quality assurance
 
 ### Single Role Execution

.claude/agents/test-fix-agent.md

@@ -0,0 +1,173 @@
+---
+name: test-fix-agent
+description: |
+  Execute tests, diagnose failures, and fix code until all tests pass. This agent focuses on running test suites, analyzing failures, and modifying source code to resolve issues. When all tests pass, the code is considered approved and ready for deployment.
+
+  Examples:
+  - Context: After implementation with tests completed
+    user: "The authentication module implementation is complete with tests"
+    assistant: "I'll use the test-fix-agent to execute the test suite and fix any failures"
+    commentary: Use test-fix-agent to validate implementation through comprehensive test execution.
+
+  - Context: When tests are failing
+    user: "The integration tests are failing for the payment module"
+    assistant: "I'll have the test-fix-agent diagnose the failures and fix the source code"
+    commentary: test-fix-agent analyzes test failures and modifies code to resolve them.
+
+  - Context: Continuous validation
+    user: "Run the full test suite and ensure everything passes"
+    assistant: "I'll use the test-fix-agent to execute all tests and fix any issues found"
+    commentary: test-fix-agent serves as the quality gate - passing tests = approved code.
+model: sonnet
+color: green
+---
+
+You are a specialized **Test Execution & Fix Agent**. Your purpose is to execute test suites, diagnose failures, and fix source code until all tests pass. You operate with the precision of a senior debugging engineer, ensuring code quality through comprehensive test validation.
+
+## Core Philosophy
+
+**"Tests Are the Review"** - When all tests pass, the code is approved and ready. No separate review process is needed.
+
+## Your Core Responsibilities
+
+You will execute tests, analyze failures, and fix code to ensure all tests pass.
+
+### Test Execution & Fixing Responsibilities:
+1. **Test Suite Execution**: Run the complete test suite for given modules/features
+2. **Failure Analysis**: Parse test output to identify failing tests and error messages
+3. **Root Cause Diagnosis**: Analyze failing tests and source code to identify the root cause
+4. **Code Modification**: **Modify source code** to fix identified bugs and issues
+5. **Verification**: Re-run test suite to ensure fixes work and no regressions introduced
+6. **Approval Certification**: When all tests pass, certify code as approved
+
+## Execution Process
+
+### 1. Context Assessment & Test Discovery
+- Analyze task context to identify test files and source code paths
+- Load test framework configuration (Jest, Pytest, Mocha, etc.)
+- Identify test command from project configuration
+
+```bash
+# Detect test framework and command
+if [ -f "package.json" ]; then
+    TEST_CMD=$(cat package.json | jq -r '.scripts.test')
+elif [ -f "pytest.ini" ] || [ -f "setup.py" ]; then
+    TEST_CMD="pytest"
+fi
+```
+
+### 2. Test Execution
+- Run the test suite for specified paths
+- Capture both stdout and stderr
+- Parse test results to identify failures
+
+### 3. Failure Diagnosis & Fixing Loop
+```
+WHILE tests are failing:
+    1. Analyze failure output
+    2. Identify root cause in source code
+    3. Modify source code to fix issue
+    4. Re-run affected tests
+    5. Verify fix doesn't break other tests
+END WHILE
+```
+
+### 4. Code Quality Certification
+- All tests pass → Code is APPROVED ✅
+- Generate summary documenting:
+  - Issues found
+  - Fixes applied
+  - Final test results
+
+## Fixing Criteria
+
+### Bug Identification
+- Logic errors causing test failures
+- Edge cases not handled properly
+- Integration issues between components
+- Incorrect error handling
+- Resource management problems
+
+### Code Modification Approach
+- **Minimal changes**: Fix only what's needed
+- **Preserve functionality**: Don't change working code
+- **Follow patterns**: Use existing code conventions
+- **Test-driven fixes**: Let tests guide the solution
+
+### Verification Standards
+- All tests pass without errors
+- No new test failures introduced
+- Performance remains acceptable
+- Code follows project conventions
+
+## Output Format
+
+When you complete a test-fix task, provide:
+
+```markdown
+# Test-Fix Summary: [Task-ID] [Feature Name]
+
+## Execution Results
+
+### Initial Test Run
+- **Total Tests**: [count]
+- **Passed**: [count]
+- **Failed**: [count]
+- **Errors**: [count]
+
+## Issues Found & Fixed
+
+### Issue 1: [Description]
+- **Test**: `tests/auth/login.test.ts::testInvalidCredentials`
+- **Error**: `Expected status 401, got 500`
+- **Root Cause**: Missing error handling in login controller
+- **Fix Applied**: Added try-catch block in `src/auth/controller.ts:45`
+- **Files Modified**: `src/auth/controller.ts`
+
+### Issue 2: [Description]
+- **Test**: `tests/payment/process.test.ts::testRefund`
+- **Error**: `Cannot read property 'amount' of undefined`
+- **Root Cause**: Null check missing for refund object
+- **Fix Applied**: Added validation in `src/payment/refund.ts:78`
+- **Files Modified**: `src/payment/refund.ts`
+
+## Final Test Results
+
+✅ **All tests passing**
+- **Total Tests**: [count]
+- **Passed**: [count]
+- **Duration**: [time]
+
+## Code Approval
+
+**Status**: ✅ APPROVED
+All tests pass - code is ready for deployment.
+
+## Files Modified
+- `src/auth/controller.ts`: Added error handling
+- `src/payment/refund.ts`: Added null validation
+```
+
+## Important Reminders
+
+**ALWAYS:**
+- **Execute tests first** - Understand what's failing before fixing
+- **Diagnose thoroughly** - Find root cause, not just symptoms
+- **Fix minimally** - Change only what's needed to pass tests
+- **Verify completely** - Run full suite after each fix
+- **Document fixes** - Explain what was changed and why
+- **Certify approval** - When tests pass, code is approved
+
+**NEVER:**
+- Skip test execution - always run tests first
+- Make changes without understanding the failure
+- Fix symptoms without addressing root cause
+- Break existing passing tests
+- Skip final verification
+- Leave tests failing - must achieve 100% pass rate
+
+## Quality Certification
+
+**Your ultimate responsibility**: Ensure all tests pass. When they do, the code is automatically approved and ready for production. You are the final quality gate.
+
+**Tests passing = Code approved = Mission complete** ✅

.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)
-2. **If `--enhance` flag present**: Execute `/enhance-prompt "[analysis-target]"` and use enhanced output
-3. Parse analysis target (original or enhanced)
-4. Detect analysis type (pattern/architecture/security/quality)
-5. Build command for selected tool with template
-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` |
+1. Parse tool selection (default: gemini)
+2. If `--enhance`: Execute `/enhance-prompt` first
+3. Detect analysis type and select template
+4. Build and execute command
+5. Return results
 
 ## 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
-SlashCommand(command="/enhance-prompt \"[analysis-target]\"")
-
-# 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]
+cd [dir] && ~/.claude/scripts/[gemini|qwen]-wrapper -p "
+PURPOSE: [analysis goal]
+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]
 "
 ```
 
-### Qwen
+**Codex**:
 ```bash
-cd [target-dir] && ~/.claude/scripts/qwen-wrapper -p "
-PURPOSE: [analysis goal from user input]
-TASK: [specific analysis task]
+codex -C [dir] --full-auto exec "
+PURPOSE: [analysis goal]
+TASK: [specific task]
 CONTEXT: @{[file-patterns]} @{CLAUDE.md}
-EXPECTED: [expected output format]
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/[category]/[template].txt) | [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]
+EXPECTED: [output format]
+RULES: [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 "
-PURPOSE: Analyze authentication patterns
-TASK: Identify auth implementation patterns and conventions
-CONTEXT: @{**/*auth*} @{CLAUDE.md}
-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
+/cli:analyze "authentication patterns"              # Gemini (default)
+/cli:analyze --tool qwen "component architecture"   # Qwen architecture
+/cli:analyze --tool codex "performance bottlenecks" # Codex deep analysis
+/cli:analyze --enhance "fix auth issues"            # Enhanced prompt first
 ```
 
 ## 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
-
-**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
+- **Active Session**: Save results to `.workflow/WFS-[id]/.chat/analysis-[timestamp].md`
+- **No Session**: Return results directly to user
 

.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
--   **Purpose**: Direct interaction with CLI tools for codebase analysis
--   **Supported Tools**: codex, gemini (default), qwen
+Direct interaction with CLI tools for codebase analysis and Q&A.
 
-### 📥 **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
--   **`--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
+## Parameters
 
-### 🔄 **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 |
-|------|----------|---------|
-| **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` |
+## Enhancement Integration
 
-### 🔄 **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
-SlashCommand(command="/enhance-prompt \"[inquiry]\"")
-
-# Step 2: Use enhanced output for chat
-# Enhanced output provides enriched context and structured intent
-```
-
-**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]
+cd [dir] && ~/.claude/scripts/[gemini|qwen]-wrapper -p "
+PURPOSE: [inquiry goal]
+TASK: [specific question]
+CONTEXT: @{CLAUDE.md} @{target_files}
+EXPECTED: [response format]
+RULES: [constraints]
 "
+
+# With --all-files
+cd [dir] && ~/.claude/scripts/[gemini|qwen]-wrapper --all-files -p "..."
 ```
 
-### ⚙️ **Execution Implementation**
-
-**Standard Template**:
+**Codex**:
 ```bash
-cd . && ~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: [user inquiry goal]
-TASK: [specific question or analysis]
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} @{inferred_or_specified_files}
-EXPECTED: Analysis with file references and code examples
-RULES: [focus areas based on inquiry]
-"
+codex -C [dir] --full-auto exec "
+PURPOSE: [inquiry goal]
+TASK: [specific question]
+CONTEXT: @{CLAUDE.md} @{target_files}
+EXPECTED: [response format]
+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 "
-PURPOSE: [user inquiry goal]
-TASK: [specific question or analysis]
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [entire codebase]
-EXPECTED: Comprehensive analysis across all files
-RULES: [focus areas based on inquiry]
-"
+/cli:chat "analyze the authentication flow"              # Gemini (default)
+/cli:chat --tool qwen "optimize React component"         # Qwen
+/cli:chat --tool codex "review security vulnerabilities" # Codex
+/cli:chat --enhance "fix the login"                      # Enhanced prompt
+/cli:chat --all-files "find all API endpoints"           # Full codebase
 ```
 
-**Example - Authentication Analysis**:
-```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
-"
-```
+## Session Persistence
 
-**Example - Performance Optimization**:
-```bash
-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]
-```
+- **Active Session**: Save to `.workflow/WFS-[id]/.chat/chat-[timestamp].md`
+- **No Session**: Return results directly

.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.
-
-**Purpose**: Execute implementation tasks using intelligent context inference and CLI tools with full permissions.
+Execute implementation tasks with YOLO permissions (auto-approves all confirmations).
 
 **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:**
-- ✅ File pattern inference confirmation
-- ✅ Gemini execution confirmation
-- ✅ File modification confirmation
-- ✅ Implementation summary generation
+## Enhancement Integration
 
-## 🎯 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):
-```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.
+**Note**: Task ID Mode uses task JSON directly (no enhancement).
 
 ## Execution Modes
 
-### 1. Description Mode (supports --enhance)
-**Input**: Natural language description
-```bash
-/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
+**1. Description Mode** (supports `--enhance`):
+- Input: Natural language description
+- Process: [Optional: Enhance] → Keyword analysis → Pattern inference → Execute
 
-### 2. Task ID Mode (no --enhance)
-**Input**: Workflow task identifier
-```bash
-/gemini:execute IMPL-001
-```
-**Process**: Task JSON parsing → Scope analysis → Context integration → Execution
+**2. Task ID Mode** (no `--enhance`):
+- Input: Workflow task identifier (e.g., `IMPL-001`)
+- Process: Task JSON parsing → Scope analysis → Execute
 
-## 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 execution logging |
-| `--save-session` | Save complete execution session to workflow |
+- `--debug`: Verbose logging
+- `--save-session`: Save execution to workflow session
 
 ## Workflow Integration
 
-### Session Management
-⚠️ **Auto-detects active session**: Checks `.workflow/.active-*` marker file
+**Session Management**: Auto-detects `.workflow/.active-*` marker
+- **Active**: Save to `.workflow/WFS-[id]/.chat/execute-[timestamp].md`
+- **None**: Create new session
 
-**Session storage:**
-- **Active session exists**: Saves to `.workflow/WFS-[topic]/.chat/execute-[timestamp].md`
-- **No active session**: Creates new session directory
+**Task Integration**: Load from `.task/[TASK-ID].json`, update status, generate summary
 
-### Task Integration
+## Command Template
+
+**Gemini/Qwen** (with YOLO approval):
 ```bash
-# Execute specific workflow task
-/gemini:execute IMPL-001
-
-# Loads from: .task/IMPL-001.json
-# Uses: task context, brainstorming refs, scope definitions
-# Updates: workflow status, generates summary
-```
-
-## 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]
+cd [dir] && ~/.claude/scripts/[gemini|qwen]-wrapper --approval-mode yolo -p "
+PURPOSE: [implementation goal]
+TASK: [specific task]
+MODE: write
+CONTEXT: @{inferred_patterns} @{CLAUDE.md}
+EXPECTED: Implementation with file:line references
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/[category]/[template].txt) | [constraints]
 "
 ```
 
-**Example**:
+**Codex**:
 ```bash
-cd . && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
-PURPOSE: Implement JWT authentication with middleware
-TASK: Create authentication system with token validation
-CONTEXT: @{**/*auth*,**/*middleware*} @{CLAUDE.md}
-EXPECTED: Auth service, middleware, tests with file modifications
-RULES: Follow existing auth patterns | Security best practices
-"
+codex -C [dir] --full-auto exec "
+PURPOSE: [implementation goal]
+TASK: [specific task]
+MODE: auto
+CONTEXT: @{inferred_patterns} @{CLAUDE.md}
+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
-```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]
-"
-```
+## Examples
 
-**Example**:
 ```bash
-cd .workflow/WFS-123 && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
-PURPOSE: Implement user profile editing
-TASK: Execute IMPL-001 implementation
-CONTEXT: @{src/user/**/*} @{.brainstorming/feature-planner/analysis.md} @{CLAUDE.md}
-EXPECTED: Profile edit API, UI components, validation, tests
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/development/feature.txt) | Type: feature, Scope: user module
-"
+/cli:execute "implement JWT authentication with middleware"  # Description mode
+/cli:execute --enhance "implement JWT authentication"        # Enhanced
+/cli:execute IMPL-001                                        # Task ID mode
+/cli:execute --tool codex "optimize database queries"        # Codex execution
 ```
 
 ## Auto-Generated Outputs
 
-### 1. Implementation Summary
-**Location**: `.summaries/[TASK-ID]-summary.md` or auto-generated ID
+- **Summary**: `.summaries/[TASK-ID]-summary.md`
+- **Session**: `.chat/execute-[timestamp].md`
 
-```markdown
-# Task Summary: [Task-ID] [Description]
+## Notes
 
-## Implementation
-- **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.
+**vs. `/cli:analyze`**: Execute performs implementation, analyze is read-only.
 

.claude/commands/task/breakdown.md

@@ -88,8 +88,9 @@ Files updated: .task/IMPL-1.json + 2 subtask files + TODO_LIST.md
 ### Agent Assignment
 - **Design/Planning** → `@planning-agent`
 - **Implementation** → `@code-developer`
-- **Testing** → `@code-review-test-agent`
-- **Review** → `@review-agent`
+- **Testing** → `@code-developer` (type: "test-gen")
+- **Test Validation** → `@test-fix-agent` (type: "test-fix")
+- **Review** → `@general-purpose` (optional)
 
 ### Context Inheritance
 - Subtasks inherit parent requirements
@@ -161,8 +162,8 @@ See @~/.claude/workflows/workflow-architecture.md for:
 
 ▸ impl-1: Build authentication (container)
   ├── impl-1.1: Design schema → @planning-agent
-  ├── impl-1.2: Implement logic → @code-developer
-  └── impl-1.3: Write tests → @code-review-test-agent
+  ├── impl-1.2: Implement logic + tests → @code-developer
+  └── impl-1.3: Execute & fix tests → @test-fix-agent
 ```
 
 ## Error Handling

.claude/commands/task/create.md

@@ -107,8 +107,9 @@ Tasks inherit from:
 Based on task type and title keywords:
 - **Build/Implement** → @code-developer
 - **Design/Plan** → @planning-agent
-- **Test/Validate** → @code-review-test-agent
-- **Review/Audit** → @review-agent`
+- **Test Generation** → @code-developer (type: "test-gen")
+- **Test Execution/Fix** → @test-fix-agent (type: "test-fix")
+- **Review/Audit** → @general-purpose (optional, only when explicitly requested)
 
 ## Validation Rules
 

.claude/commands/task/execute.md

@@ -24,8 +24,8 @@ examples:
     -   Executes step-by-step, requiring user confirmation at each checkpoint.
     -   Allows for dynamic adjustments and manual review during the process.
 -   **review**
-    -   Executes under the supervision of a `@review-agent`.
-    -   Performs quality checks and provides detailed feedback at each step.
+    -   Optional manual review using `@general-purpose`.
+    -   Used only when explicitly requested by user.
 
 ### 🤖 **Agent Selection Logic**
 
@@ -45,10 +45,12 @@ FUNCTION select_agent(task, agent_override):
                 RETURN "@code-developer"
             WHEN CONTAINS "Design schema", "Plan":
                 RETURN "@planning-agent"
-            WHEN CONTAINS "Write tests":
-                RETURN "@code-review-test-agent"
+            WHEN CONTAINS "Write tests", "Generate tests":
+                RETURN "@code-developer" // type: test-gen
+            WHEN CONTAINS "Execute tests", "Fix tests", "Validate":
+                RETURN "@test-fix-agent" // type: test-fix
             WHEN CONTAINS "Review code":
-                RETURN "@review-agent"
+                RETURN "@general-purpose" // Optional manual review
             DEFAULT:
                 RETURN "@code-developer" // Default agent
         END CASE
@@ -232,13 +234,15 @@ Different agents receive context tailored to their function, including implement
 - Implementation risks and mitigation strategies
 - Architecture implications from implementation.context_notes
 
-**`@code-review-test-agent`**: 
-- Files to test from implementation.files[].path
-- Logic flows to validate from implementation.modifications.logic_flow
-- Error conditions to test from implementation.context_notes.error_handling
-- Performance benchmarks from implementation.context_notes.performance_considerations
+**`@test-fix-agent`**:
+- Test files to execute from task.context.focus_paths
+- Source files to fix from implementation.files[].path
+- Expected behaviors from implementation.modifications.logic_flow
+- Error conditions to validate from implementation.context_notes.error_handling
+- Performance requirements from implementation.context_notes.performance_considerations
 
-**`@review-agent`**: 
+**`@general-purpose`**:
+- Used for optional manual reviews when explicitly requested
 - Code quality standards and implementation patterns
 - Security considerations from implementation.context_notes.risks
 - Dependency validation from implementation.context_notes.dependencies

.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

@@ -5,8 +5,8 @@ usage: /workflow:brainstorm:artifacts "<topic>" [--roles "role1,role2,role3"]
 argument-hint: "topic or challenge description for framework generation"
 examples:
   - /workflow:brainstorm:artifacts "Build real-time collaboration feature"
-  - /workflow:brainstorm:artifacts "Optimize database performance" --roles "system-architect,data-architect,security-expert"
-  - /workflow:brainstorm:artifacts "Implement secure authentication system" --roles "ui-designer,security-expert,user-researcher"
+  - /workflow:brainstorm:artifacts "Optimize database performance" --roles "system-architect,data-architect,subject-matter-expert"
+  - /workflow:brainstorm:artifacts "Implement secure authentication system" --roles "ui-designer,ux-expert,subject-matter-expert"
 allowed-tools: TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)
 ---
 
@@ -91,10 +91,11 @@ allowed-tools: TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)
 **Document Structure**:
 ```
 .workflow/WFS-[topic]/.brainstorming/
-├── topic-framework.md          # ★ STRUCTURED FRAMEWORK DOCUMENT
-└── workflow-session.json               # Framework metadata and role assignments
+└── topic-framework.md          # ★ STRUCTURED FRAMEWORK DOCUMENT
 ```
 
+**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
@@ -109,7 +110,7 @@ Framework content adapts based on `--roles` parameter:
 - **Scope**: [Topic boundaries relevant to selected roles]
 - **Objectives**: [Goals from perspective of selected roles]
 - **Context**: [Background focusing on role-specific concerns]
-- **Target Roles**: ui-designer, system-architect, security-expert
+- **Target Roles**: ui-designer, system-architect, subject-matter-expert
 
 ## Role-Specific Discussion Points
 
@@ -135,21 +136,21 @@ Framework content adapts based on `--roles` parameter:
    - What are the performance requirements?
    - What dependencies must be managed?
 
-### For Security Expert
-1. **Security Requirements**
-   - What are the key security concerns?
-   - What threat vectors must be addressed?
-   - What compliance requirements apply?
+### For Subject Matter Expert
+1. **Domain Expertise & Standards**
+   - What industry standards and best practices apply?
+   - What regulatory compliance requirements exist?
+   - What domain-specific patterns should be followed?
 
-2. **Security Implementation**
-   - What authentication/authorization is needed?
-   - What data protection mechanisms are required?
-   - How to handle security incidents?
+2. **Technical Quality & Risk**
+   - What technical debt considerations exist?
+   - What scalability and maintenance implications apply?
+   - What knowledge transfer and documentation is needed?
 
 ## Cross-Role Integration Points
 - How do UI decisions impact architecture?
 - How does architecture constrain UI possibilities?
-- What security requirements affect both UI and architecture?
+- What domain standards affect both UI and architecture?
 
 ## Framework Usage
 **For Role Agents**: Address your specific section + integration points
@@ -157,7 +158,7 @@ Framework content adapts based on `--roles` parameter:
 **Update Process**: Use /workflow:brainstorm:artifacts to update
 
 ---
-*Generated for roles: ui-designer, system-architect, security-expert*
+*Generated for roles: ui-designer, system-architect, subject-matter-expert*
 *Last updated: [timestamp]*
 ```
 
@@ -200,9 +201,9 @@ Framework content adapts based on `--roles` parameter:
 
 ## Available Role Perspectives
 Framework supports analysis from any of these roles:
-- system-architect, ui-designer, security-expert
-- user-researcher, product-manager, business-analyst
-- data-architect, innovation-lead, feature-planner
+- **Technical**: system-architect, data-architect, subject-matter-expert
+- **Product & Design**: ui-designer, ux-expert, product-manager, product-owner
+- **Agile & Quality**: scrum-master, test-strategist
 
 ---
 *Comprehensive framework - adaptable to any role*
@@ -216,17 +217,17 @@ Framework supports analysis from any of these roles:
 **Technical Roles**:
 - `system-architect`: Architecture patterns, scalability, technology stack, integration
 - `data-architect`: Data modeling, processing workflows, analytics, storage
-- `security-expert`: Security requirements, threat modeling, compliance, protection
+- `subject-matter-expert`: Domain expertise, industry standards, compliance, best practices
 
 **Product & Design Roles**:
 - `ui-designer`: User interface, visual design, interaction patterns, accessibility
-- `user-researcher`: User needs, behavior analysis, usability testing, personas
+- `ux-expert`: User experience optimization, usability testing, interaction design, design systems
 - `product-manager`: Business value, feature prioritization, market positioning, roadmap
+- `product-owner`: Backlog management, user stories, acceptance criteria, stakeholder alignment
 
-**Business Roles**:
-- `business-analyst`: Process optimization, requirements analysis, cost-benefit, ROI
-- `innovation-lead`: Emerging technologies, competitive advantage, transformation, trends
-- `feature-planner`: Feature specification, user stories, acceptance criteria, dependencies
+**Agile & Quality Roles**:
+- `scrum-master`: Sprint planning, team dynamics, process optimization, delivery management
+- `test-strategist`: Testing strategies, quality assurance, test automation, validation approaches
 
 ### Dynamic Discussion Point Generation
 
@@ -248,23 +249,32 @@ Generate:
 
 #### Example 1: Architecture-Heavy Topic
 ```bash
-/workflow:brainstorm:artifacts "Design scalable microservices platform" --roles "system-architect,data-architect,security-expert"
+/workflow:brainstorm:artifacts "Design scalable microservices platform" --roles "system-architect,data-architect,subject-matter-expert"
 ```
 **Generated framework focuses on**:
 - Service architecture and communication patterns
 - Data flow and storage strategies
-- Security boundaries and authentication
+- Domain standards and best practices
 
 #### Example 2: User-Focused Topic
 ```bash
-/workflow:brainstorm:artifacts "Improve user onboarding experience" --roles "ui-designer,user-researcher,product-manager"
+/workflow:brainstorm:artifacts "Improve user onboarding experience" --roles "ui-designer,ux-expert,product-manager"
 ```
 **Generated framework focuses on**:
 - Onboarding flow and UI components
-- User behavior and pain points
+- User experience optimization and usability
 - Business value and success metrics
 
-#### Example 3: Comprehensive Analysis
+#### Example 3: Agile Delivery Topic
+```bash
+/workflow:brainstorm:artifacts "Optimize sprint delivery process" --roles "scrum-master,product-owner,test-strategist"
+```
+**Generated framework focuses on**:
+- Sprint planning and team collaboration
+- Backlog management and prioritization
+- Quality assurance and testing strategies
+
+#### Example 4: Comprehensive Analysis
 ```bash
 /workflow:brainstorm:artifacts "Build real-time collaboration feature"
 ```

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

@@ -18,15 +18,17 @@ allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*
 ```
 
 ## Role Selection Logic
-- **Technical & Architecture**: `architecture|system|performance|database|security` → system-architect, data-architect, security-expert
-- **Product & UX**: `user|ui|ux|interface|design|product|feature` → ui-designer, user-researcher, product-manager
+- **Technical & Architecture**: `architecture|system|performance|database|security` → system-architect, data-architect, security-expert, subject-matter-expert
+- **Product & UX**: `user|ui|ux|interface|design|product|feature|experience` → ui-designer, user-researcher, product-manager, ux-expert, product-owner
 - **Business & Process**: `business|process|workflow|cost|innovation|testing` → business-analyst, innovation-lead, test-strategist
+- **Agile & Delivery**: `agile|sprint|scrum|team|collaboration|delivery` → scrum-master, product-owner
+- **Domain Expertise**: `domain|standard|compliance|expertise|regulation` → subject-matter-expert
 - **Multi-role**: Complex topics automatically select 2-3 complementary roles
 - **Default**: `product-manager` if no clear match
 
 **Template Loading**: `bash($(cat "~/.claude/workflows/cli-templates/planning-roles/<role-name>.md"))`
 **Template Source**: `.claude/workflows/cli-templates/planning-roles/`
-**Available Roles**: business-analyst, data-architect, feature-planner, innovation-lead, product-manager, security-expert, system-architect, test-strategist, ui-designer, user-researcher
+**Available Roles**: data-architect, product-manager, product-owner, scrum-master, subject-matter-expert, system-architect, test-strategist, ui-designer, ux-expert
 
 **Example**:
 ```bash
@@ -72,9 +74,10 @@ Auto command coordinates independent specialized commands:
 4. **Command coordination**: SlashCommand handles execution and validation
 
 **Role Selection Logic**:
-- **Technical**: `architecture|system|performance|database|security` → system-architect, data-architect, security-expert
-- **Product & UX**: `user|ui|ux|interface|design|product|feature` → ui-designer, user-researcher, product-manager
-- **Business**: `business|process|workflow|cost|innovation` → business-analyst, innovation-lead
+- **Technical**: `architecture|system|performance|database` → system-architect, data-architect, subject-matter-expert
+- **Product & UX**: `user|ui|ux|interface|design|product|feature|experience` → ui-designer, ux-expert, product-manager, product-owner
+- **Agile & Delivery**: `agile|sprint|scrum|team|collaboration|delivery` → scrum-master, product-owner
+- **Domain Expertise**: `domain|standard|compliance|expertise|regulation` → subject-matter-expert
 - **Auto-select**: 2-3 most relevant roles based on topic analysis
 
 ### Simplified Processing Standards
@@ -146,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
@@ -159,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/auto-squeeze.md

@@ -61,16 +61,16 @@ Use keyword analysis to auto-select 2-3 roles:
 
 **Role Selection Logic**:
 - **Technical/Architecture keywords**: `architecture|system|performance|database|api|backend|scalability`
-  → system-architect, data-architect, security-expert
+  → system-architect, data-architect, subject-matter-expert
 - **UI/UX keywords**: `user|ui|ux|interface|design|frontend|experience`
-  → ui-designer, user-researcher
+  → ui-designer, ux-expert
 - **Product/Business keywords**: `product|feature|business|workflow|process|customer`
-  → product-manager, business-analyst
-- **Security keywords**: `security|auth|permission|encryption|compliance`
-  → security-expert
-- **Innovation keywords**: `innovation|new|disrupt|transform|emerging`
-  → innovation-lead
-- **Default**: ui-designer (if no clear match)
+  → product-manager, product-owner
+- **Agile/Delivery keywords**: `agile|sprint|scrum|team|collaboration|delivery`
+  → scrum-master, product-owner
+- **Domain Expertise keywords**: `domain|standard|compliance|expertise|regulation`
+  → subject-matter-expert
+- **Default**: product-manager (if no clear match)
 
 **Selection Rules**:
 - Maximum 3 roles
@@ -91,14 +91,14 @@ Execute each selected role command one by one:
 
 **Commands**:
 - `SlashCommand(command="/workflow:brainstorm:ui-designer")`
+- `SlashCommand(command="/workflow:brainstorm:ux-expert")`
 - `SlashCommand(command="/workflow:brainstorm:system-architect")`
-- `SlashCommand(command="/workflow:brainstorm:security-expert")`
-- `SlashCommand(command="/workflow:brainstorm:user-researcher")`
-- `SlashCommand(command="/workflow:brainstorm:product-manager")`
-- `SlashCommand(command="/workflow:brainstorm:business-analyst")`
 - `SlashCommand(command="/workflow:brainstorm:data-architect")`
-- `SlashCommand(command="/workflow:brainstorm:innovation-lead")`
-- `SlashCommand(command="/workflow:brainstorm:feature-planner")`
+- `SlashCommand(command="/workflow:brainstorm:product-manager")`
+- `SlashCommand(command="/workflow:brainstorm:product-owner")`
+- `SlashCommand(command="/workflow:brainstorm:scrum-master")`
+- `SlashCommand(command="/workflow:brainstorm:subject-matter-expert")`
+- `SlashCommand(command="/workflow:brainstorm:test-strategist")`
 
 **Validation** (after each role):
 - File `.workflow/[session]/.brainstorming/[role]/analysis.md` exists
@@ -202,8 +202,8 @@ Return summary to user
 **Keywords detected**: user, interface, design
 **Selected roles**:
 - ui-designer (primary: UI/UX match)
-- user-researcher (secondary: user experience)
-- security-expert (complementary: auth security)
+- ux-expert (secondary: user experience)
+- subject-matter-expert (complementary: auth standards)
 
 ### Example 2: Architecture Topic
 **Topic**: "Design scalable microservices architecture"
@@ -211,15 +211,15 @@ Return summary to user
 **Selected roles**:
 - system-architect (primary: architecture match)
 - data-architect (secondary: scalability/data)
-- security-expert (complementary: system security)
+- subject-matter-expert (complementary: domain expertise)
 
-### Example 3: Business Process Topic
-**Topic**: "Optimize customer onboarding workflow"
-**Keywords detected**: workflow, process, customer
+### Example 3: Agile Delivery Topic
+**Topic**: "Optimize team sprint planning and delivery process"
+**Keywords detected**: sprint, team, delivery, process
 **Selected roles**:
-- business-analyst (primary: process match)
-- product-manager (secondary: customer focus)
-- ui-designer (complementary: user experience)
+- scrum-master (primary: agile process match)
+- product-owner (secondary: backlog/delivery focus)
+- product-manager (complementary: product strategy)
 
 ## Error Handling
 

.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/innovation-lead.md

@@ -1,254 +0,0 @@
----
-name: innovation-lead
-description: Generate or update innovation-lead/analysis.md addressing topic-framework discussion points
-usage: /workflow:brainstorm:innovation-lead [topic]
-argument-hint: "optional topic - uses existing framework if available"
-examples:
-  - /workflow:brainstorm:innovation-lead
-  - /workflow:brainstorm:innovation-lead "AI integration opportunities"
-  - /workflow:brainstorm:innovation-lead "future technology trends"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
----
-
-## 🚀 **Role Overview: Innovation Lead**
-
-### Role Definition
-Visionary technology strategist responsible for identifying emerging technology trends, evaluating disruptive innovation opportunities, and designing future-ready solutions that create competitive advantage and drive market transformation.
-
-### Core Responsibilities
-- **Trend Identification**: Identify and analyze emerging technology trends and market opportunities
-- **Innovation Strategy**: Develop innovation roadmaps and technology development strategies
-- **Technology Assessment**: Evaluate new technology application potential and feasibility
-- **Future Planning**: Design forward-looking product and service concepts
-
-### Focus Areas
-- **Emerging Technologies**: AI, blockchain, IoT, AR/VR, quantum computing, and other frontier technologies
-- **Market Trends**: Industry transformation, user behavior evolution, business model innovation
-- **Innovation Opportunities**: Disruptive innovation, blue ocean markets, technology convergence opportunities
-- **Future Vision**: Long-term technology roadmaps, proof of concepts, prototype development
-
-### Success Metrics
-- Innovation impact and market differentiation
-- Technology adoption rates and competitive advantage
-- Future readiness and strategic positioning
-- Breakthrough opportunity identification and validation
-
-## 🧠 **Analysis Framework**
-
-@~/.claude/workflows/brainstorming-principles.md
-
-### Key Analysis Questions
-
-**1. Emerging Trends and Technology Opportunities**
-- Which emerging technologies will have the greatest impact on our industry?
-- What is the technology maturity level and adoption timeline?
-- What new opportunities does technology convergence create?
-
-**2. Disruption Potential and Innovation Assessment**
-- What is the potential for disruptive innovation and its impact?
-- What innovation opportunities exist within current solutions?
-- What unmet market needs and demands exist?
-
-**3. Competitive Advantage and Market Analysis**
-- What are competitors' innovation strategies and directions?
-- What market gaps and blue ocean opportunities exist?
-- What technological barriers and first-mover advantages are available?
-
-**4. Implementation and Risk Assessment**
-- What is the feasibility and risk of technology implementation?
-- What are the investment requirements and expected returns?
-- What organizational innovation capabilities and adaptability are needed?
-
-## ⚡ **Two-Step Execution Flow**
-
-### ⚠️ Session Management - FIRST STEP
-Session detection and selection:
-```bash
-# Check for active sessions
-active_sessions=$(find .workflow -name ".active-*" 2>/dev/null)
-if [ multiple_sessions ]; then
-  prompt_user_to_select_session()
-else
-  use_existing_or_create_new()
-fi
-```
-
-### Step 1: Context Gathering Phase
-**Innovation Lead Perspective Questioning**
-
-Before agent assignment, gather comprehensive innovation lead context:
-
-#### 📋 Role-Specific Questions
-
-**1. Emerging Trends and Future Technologies**
-- What emerging technologies or trends do you think will be most relevant to this topic?
-- Are there any specific industries or markets you want to explore for innovation opportunities?
-- What time horizon are you considering (near-term, medium-term, long-term disruption)?
-- Are there any particular technology domains you want to focus on (AI, IoT, blockchain, etc.)?
-
-**2. Innovation Opportunities and Market Potential**
-- What current limitations or pain points could be addressed through innovation?
-- Are there any unmet market needs or underserved segments you're aware of?
-- What would disruptive success look like in this context?
-- Are there cross-industry innovations that could be applied to this domain?
-
-**3. Disruption Potential and Competitive Landscape**
-- Who are the current market leaders and what are their innovation strategies?
-- What startup activity or venture capital investment trends are you seeing?
-- Are there any potential platform shifts or ecosystem changes on the horizon?
-- What would make a solution truly differentiated in the marketplace?
-
-**4. Implementation and Strategic Considerations**
-- What organizational capabilities or partnerships would be needed for innovation?
-- Are there regulatory, technical, or market barriers to consider?
-- What level of risk tolerance exists for breakthrough vs. incremental innovation?
-- How important is first-mover advantage versus fast-follower strategies?
-
-#### Context Validation
-- **Minimum Response**: Each answer must be ≥50 characters
-- **Re-prompting**: Insufficient detail triggers follow-up questions
-- **Context Storage**: Save responses to `.brainstorming/innovation-lead-context.md`
-
-### Step 2: Agent Assignment with Flow Control
-**Dedicated Agent Execution**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute dedicated innovation lead conceptual analysis for: {topic}
-
-ASSIGNED_ROLE: innovation-lead
-OUTPUT_LOCATION: .brainstorming/innovation-lead/
-USER_CONTEXT: {validated_responses_from_context_gathering}
-
-Flow Control Steps:
-[
-  {
-    \"step\": \"load_role_template\",
-    \"action\": \"Load innovation-lead planning template\",
-    \"command\": \"bash($(cat ~/.claude/workflows/cli-templates/planning-roles/innovation-lead.md))\",
-    \"output_to\": \"role_template\"
-  }
-]
-
-Conceptual Analysis Requirements:
-- Apply innovation lead perspective to topic analysis
-- Focus on emerging trends, disruption potential, competitive advantage, and future opportunities
-- Use loaded role template framework for analysis structure
-- Generate role-specific deliverables in designated output location
-- Address all user context from questioning phase
-
-Deliverables:
-- analysis.md: Main innovation lead analysis
-- recommendations.md: Innovation lead recommendations
-- deliverables/: Innovation lead-specific outputs as defined in role template
-
-Embody innovation lead role expertise for comprehensive conceptual planning."
-```
-
-### Progress Tracking
-TodoWrite tracking for two-step process:
-```json
-[
-  {"content": "Gather innovation lead context through role-specific questioning", "status": "in_progress", "activeForm": "Gathering context"},
-  {"content": "Validate context responses and save to innovation-lead-context.md", "status": "pending", "activeForm": "Validating context"},
-  {"content": "Load innovation-lead planning template via flow control", "status": "pending", "activeForm": "Loading template"},
-  {"content": "Execute dedicated conceptual-planning-agent for innovation-lead role", "status": "pending", "activeForm": "Executing agent"}
-]
-```
-
-## 📋 **TodoWrite Integration**
-
-### Workflow Progress Tracking
-```javascript
-TodoWrite({
-  todos: [
-    {
-      content: "Detect active session and locate topic framework",
-      status: "in_progress",
-      activeForm: "Detecting session and framework"
-    },
-    {
-      content: "Load topic-framework.md and session metadata for context",
-      status: "pending",
-      activeForm: "Loading framework and session context"
-    },
-    {
-      content: "Execute innovation-lead analysis using conceptual-planning-agent with FLOW_CONTROL",
-      status: "pending",
-      activeForm: "Executing innovation-lead framework analysis"
-    },
-    {
-      content: "Generate analysis.md addressing all framework discussion points",
-      status: "pending",
-      activeForm: "Generating structured innovation-lead analysis"
-    },
-    {
-      content: "Update session.json with innovation-lead completion status",
-      status: "pending",
-      activeForm: "Updating session metadata"
-    }
-  ]
-});
-```
-
-## 📊 **Output Structure**
-
-### Framework-Based Analysis
-```
-.workflow/WFS-{session}/.brainstorming/innovation-lead/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
-```
-
-### Analysis Document Structure
-```markdown
-# Innovation Lead Analysis: [Topic from Framework]
-
-## Framework Reference
-**Topic Framework**: @../topic-framework.md
-**Role Focus**: Innovation and Emerging Technology perspective
-
-## Discussion Points Analysis
-[Address each point from topic-framework.md with innovation expertise]
-
-### Core Requirements (from framework)
-[Innovation perspective on emerging technology requirements]
-
-### Technical Considerations (from framework)
-[Future technology and breakthrough considerations]
-
-### User Experience Factors (from framework)
-[Future user behavior and interaction trends]
-
-### Implementation Challenges (from framework)
-[Innovation implementation and market adoption considerations]
-
-### Success Metrics (from framework)
-[Innovation success metrics and breakthrough criteria]
-
-## Innovation Specific Recommendations
-[Role-specific innovation opportunities and breakthrough concepts]
-
----
-*Generated by innovation-lead analysis addressing structured framework*
-```
-
-## 🔄 **Session Integration**
-
-### Completion Status Update
-```json
-{
-  "innovation_lead": {
-    "status": "completed",
-    "framework_addressed": true,
-    "output_location": ".workflow/WFS-{session}/.brainstorming/innovation-lead/analysis.md",
-    "framework_reference": "@../topic-framework.md"
-  }
-}
-```
-
-### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion points
-- **Cross-Role Synthesis**: Innovation insights available for synthesis-report.md integration
-- **Agent Autonomy**: Independent execution with framework guidance

.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

@@ -1,31 +1,31 @@
 ---
-name: business-analyst
-description: Generate or update business-analyst/analysis.md addressing topic-framework discussion points
-usage: /workflow:brainstorm:business-analyst [topic]
+name: product-owner
+description: Generate or update product-owner/analysis.md addressing topic-framework discussion points
+usage: /workflow:brainstorm:product-owner [topic]
 argument-hint: "optional topic - uses existing framework if available"
 examples:
-  - /workflow:brainstorm:business-analyst
-  - /workflow:brainstorm:business-analyst "workflow automation opportunities"
-  - /workflow:brainstorm:business-analyst "business process optimization"
+  - /workflow:brainstorm:product-owner
+  - /workflow:brainstorm:product-owner "user authentication redesign"
+  - /workflow:brainstorm:product-owner "mobile app performance optimization"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
 
-## 📊 **Business Analyst Analysis Generator**
+## 🎯 **Product Owner Analysis Generator**
 
 ### Purpose
-**Specialized command for generating business-analyst/analysis.md** that addresses topic-framework.md discussion points from business analysis perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating product-owner/analysis.md** that addresses topic-framework.md discussion points from product backlog and feature prioritization perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
 - **Framework-based Analysis**: Address each discussion point in topic-framework.md
-- **Business Analysis Focus**: Process optimization, requirements analysis, and business efficiency perspective
+- **Product Backlog Focus**: Feature prioritization, user stories, and acceptance criteria
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
 
 ### Analysis Scope
-- **Process Analysis**: Analyze existing business processes for efficiency and improvement opportunities
-- **Requirements Analysis**: Identify and define business requirements and functional specifications
-- **Value Analysis**: Assess cost-benefit and ROI of business initiatives
-- **Change Management**: Plan organizational change and process transformation
+- **Backlog Management**: User story creation, refinement, and prioritization
+- **Stakeholder Alignment**: Requirements gathering, value definition, and expectation management
+- **Feature Prioritization**: ROI analysis, MoSCoW method, and value-driven delivery
+- **Acceptance Criteria**: Definition of Done, acceptance testing, and quality standards
 
 ## ⚙️ **Execution Protocol**
 
@@ -68,11 +68,11 @@ ELSE:
 Task(conceptual-planning-agent): "
 [FLOW_CONTROL]
 
-Execute business-analyst analysis for existing topic framework
+Execute product-owner analysis for existing topic framework
 
 ## Context Loading
-ASSIGNED_ROLE: business-analyst
-OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/business-analyst/
+ASSIGNED_ROLE: product-owner
+OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/product-owner/
 ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 ## Flow Control Steps
@@ -82,29 +82,29 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
    - Output: topic_framework_content
 
 2. **load_role_template**
-   - Action: Load business-analyst planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/business-analyst.md))
+   - Action: Load product-owner planning template
+   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/product-owner.md))
    - Output: role_template_guidelines
 
 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
-**Framework Reference**: Address all discussion points in topic-framework.md from business analysis perspective
-**Role Focus**: Process optimization, requirements analysis, business efficiency
+**Framework Reference**: Address all discussion points in topic-framework.md from product backlog and feature prioritization perspective
+**Role Focus**: Backlog management, stakeholder alignment, feature prioritization, acceptance criteria
 **Structured Approach**: Create analysis.md addressing framework discussion points
 **Template Integration**: Apply role template guidelines within framework structure
 
 ## Expected Deliverables
-1. **analysis.md**: Comprehensive business analysis addressing all framework discussion points
+1. **analysis.md**: Comprehensive product ownership analysis addressing all framework discussion points
 2. **Framework Reference**: Include @../topic-framework.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with business analysis expertise
-- Provide process optimization recommendations and requirements specifications
-- Include cost-benefit analysis and change management considerations
+- Address each discussion point from topic-framework.md with product ownership expertise
+- Provide actionable user stories and acceptance criteria definitions
+- Include feature prioritization and stakeholder alignment strategies
 - Reference framework document using @ notation for integration
 "
 ```
@@ -126,17 +126,17 @@ TodoWrite({
       activeForm: "Loading framework and session context"
     },
     {
-      content: "Execute business-analyst analysis using conceptual-planning-agent with FLOW_CONTROL",
+      content: "Execute product-owner analysis using conceptual-planning-agent with FLOW_CONTROL",
       status: "pending",
-      activeForm: "Executing business-analyst framework analysis"
+      activeForm: "Executing product-owner framework analysis"
     },
     {
       content: "Generate analysis.md addressing all framework discussion points",
       status: "pending",
-      activeForm: "Generating structured business-analyst analysis"
+      activeForm: "Generating structured product-owner analysis"
     },
     {
-      content: "Update session.json with business-analyst completion status",
+      content: "Update workflow-session.json with product-owner completion status",
       status: "pending",
       activeForm: "Updating session metadata"
     }
@@ -148,41 +148,41 @@ TodoWrite({
 
 ### Framework-Based Analysis
 ```
-.workflow/WFS-{session}/.brainstorming/business-analyst/
+.workflow/WFS-{session}/.brainstorming/product-owner/
 └── analysis.md    # Structured analysis addressing topic-framework.md discussion points
 ```
 
 ### Analysis Document Structure
 ```markdown
-# Business Analyst Analysis: [Topic from Framework]
+# Product Owner Analysis: [Topic from Framework]
 
 ## Framework Reference
 **Topic Framework**: @../topic-framework.md
-**Role Focus**: Business Analysis perspective
+**Role Focus**: Product Backlog & Feature Prioritization perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with business analysis expertise]
+[Address each point from topic-framework.md with product ownership expertise]
 
 ### Core Requirements (from framework)
-[Business analysis perspective on requirements]
+[User story formulation and backlog refinement perspective]
 
 ### Technical Considerations (from framework)
-[Business process and workflow considerations]
+[Technical feasibility and implementation sequencing considerations]
 
 ### User Experience Factors (from framework)
-[Business user experience and stakeholder considerations]
+[User value definition and acceptance criteria analysis]
 
 ### Implementation Challenges (from framework)
-[Change management and process transformation challenges]
+[Sprint planning, dependency management, and delivery strategies]
 
 ### Success Metrics (from framework)
-[Business success metrics and performance indicators]
+[Feature adoption, value delivery metrics, and stakeholder satisfaction indicators]
 
-## Business Analysis Specific Recommendations
-[Role-specific business process recommendations and solutions]
+## Product Owner Specific Recommendations
+[Role-specific backlog management and feature prioritization strategies]
 
 ---
-*Generated by business-analyst analysis addressing structured framework*
+*Generated by product-owner analysis addressing structured framework*
 ```
 
 ## 🔄 **Session Integration**
@@ -190,10 +190,10 @@ TodoWrite({
 ### Completion Status Update
 ```json
 {
-  "business_analyst": {
+  "product_owner": {
     "status": "completed",
     "framework_addressed": true,
-    "output_location": ".workflow/WFS-{session}/.brainstorming/business-analyst/analysis.md",
+    "output_location": ".workflow/WFS-{session}/.brainstorming/product-owner/analysis.md",
     "framework_reference": "@../topic-framework.md"
   }
 }
@@ -201,5 +201,5 @@ TodoWrite({
 
 ### Integration Points
 - **Framework Reference**: @../topic-framework.md for structured discussion points
-- **Cross-Role Synthesis**: Business analysis insights available for synthesis-report.md integration
-- **Agent Autonomy**: Independent execution with framework guidance
+- **Cross-Role Synthesis**: Product ownership insights available for synthesis-report.md integration
+- **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,31 +1,31 @@
 ---
-name: security-expert
-description: Generate or update security-expert/analysis.md addressing topic-framework discussion points
-usage: /workflow:brainstorm:security-expert [topic]
+name: scrum-master
+description: Generate or update scrum-master/analysis.md addressing topic-framework discussion points
+usage: /workflow:brainstorm:scrum-master [topic]
 argument-hint: "optional topic - uses existing framework if available"
 examples:
-  - /workflow:brainstorm:security-expert
-  - /workflow:brainstorm:security-expert "user authentication security review"
-  - /workflow:brainstorm:security-expert "API security architecture"
+  - /workflow:brainstorm:scrum-master
+  - /workflow:brainstorm:scrum-master "user authentication redesign"
+  - /workflow:brainstorm:scrum-master "mobile app performance optimization"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
 
-## 🔒 **Security Expert Analysis Generator**
+## 🎯 **Scrum Master Analysis Generator**
 
 ### Purpose
-**Specialized command for generating security-expert/analysis.md** that addresses topic-framework.md discussion points from cybersecurity perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating scrum-master/analysis.md** that addresses topic-framework.md discussion points from agile process and team collaboration perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
 - **Framework-based Analysis**: Address each discussion point in topic-framework.md
-- **Cybersecurity Focus**: Threat modeling, security architecture, and risk management
+- **Agile Process Focus**: Sprint planning, team dynamics, and delivery optimization
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
 
 ### Analysis Scope
-- **Threat Modeling**: Attack vectors, threat actors, and vulnerability assessment
-- **Security Architecture**: Controls, defensive measures, and compliance
-- **Risk Management**: Risk assessment, mitigation, and security policies
-- **Implementation Security**: Integration, monitoring, and incident response
+- **Sprint Planning**: Task breakdown, estimation, and iteration planning
+- **Team Collaboration**: Communication patterns, impediment removal, and facilitation
+- **Process Optimization**: Agile ceremonies, retrospectives, and continuous improvement
+- **Delivery Management**: Velocity tracking, burndown analysis, and release planning
 
 ## ⚙️ **Execution Protocol**
 
@@ -68,11 +68,11 @@ ELSE:
 Task(conceptual-planning-agent): "
 [FLOW_CONTROL]
 
-Execute security-expert analysis for existing topic framework
+Execute scrum-master analysis for existing topic framework
 
 ## Context Loading
-ASSIGNED_ROLE: security-expert
-OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/security-expert/
+ASSIGNED_ROLE: scrum-master
+OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/scrum-master/
 ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 ## Flow Control Steps
@@ -82,29 +82,29 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
    - Output: topic_framework_content
 
 2. **load_role_template**
-   - Action: Load security-expert planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/security-expert.md))
+   - Action: Load scrum-master planning template
+   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/scrum-master.md))
    - Output: role_template_guidelines
 
 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
-**Framework Reference**: Address all discussion points in topic-framework.md from cybersecurity perspective
-**Role Focus**: Threat modeling, security architecture, risk management, compliance
+**Framework Reference**: Address all discussion points in topic-framework.md from agile process and team collaboration perspective
+**Role Focus**: Sprint planning, team dynamics, process optimization, delivery management
 **Structured Approach**: Create analysis.md addressing framework discussion points
 **Template Integration**: Apply role template guidelines within framework structure
 
 ## Expected Deliverables
-1. **analysis.md**: Comprehensive security analysis addressing all framework discussion points
+1. **analysis.md**: Comprehensive agile process analysis addressing all framework discussion points
 2. **Framework Reference**: Include @../topic-framework.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with cybersecurity expertise
-- Provide actionable security controls and threat mitigation strategies
-- Include compliance requirements and risk assessment insights
+- Address each discussion point from topic-framework.md with scrum mastery expertise
+- Provide actionable sprint planning and team facilitation strategies
+- Include process optimization and impediment removal insights
 - Reference framework document using @ notation for integration
 "
 ```
@@ -126,17 +126,17 @@ TodoWrite({
       activeForm: "Loading framework and session context"
     },
     {
-      content: "Execute security-expert analysis using conceptual-planning-agent with FLOW_CONTROL",
+      content: "Execute scrum-master analysis using conceptual-planning-agent with FLOW_CONTROL",
       status: "pending",
-      activeForm: "Executing security-expert framework analysis"
+      activeForm: "Executing scrum-master framework analysis"
     },
     {
       content: "Generate analysis.md addressing all framework discussion points",
       status: "pending",
-      activeForm: "Generating structured security-expert analysis"
+      activeForm: "Generating structured scrum-master analysis"
     },
     {
-      content: "Update session.json with security-expert completion status",
+      content: "Update workflow-session.json with scrum-master completion status",
       status: "pending",
       activeForm: "Updating session metadata"
     }
@@ -148,41 +148,41 @@ TodoWrite({
 
 ### Framework-Based Analysis
 ```
-.workflow/WFS-{session}/.brainstorming/security-expert/
+.workflow/WFS-{session}/.brainstorming/scrum-master/
 └── analysis.md    # Structured analysis addressing topic-framework.md discussion points
 ```
 
 ### Analysis Document Structure
 ```markdown
-# Security Expert Analysis: [Topic from Framework]
+# Scrum Master Analysis: [Topic from Framework]
 
 ## Framework Reference
 **Topic Framework**: @../topic-framework.md
-**Role Focus**: Cybersecurity perspective
+**Role Focus**: Agile Process & Team Collaboration perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with cybersecurity expertise]
+[Address each point from topic-framework.md with scrum mastery expertise]
 
 ### Core Requirements (from framework)
-[Security perspective on threat modeling and protection requirements]
+[Sprint planning and iteration breakdown perspective]
 
 ### Technical Considerations (from framework)
-[Security architecture and technical control considerations]
+[Technical debt management and process considerations]
 
 ### User Experience Factors (from framework)
-[Security usability and user protection considerations]
+[User story refinement and acceptance criteria analysis]
 
 ### Implementation Challenges (from framework)
-[Security implementation and compliance considerations]
+[Impediment identification and removal strategies]
 
 ### Success Metrics (from framework)
-[Security success metrics and risk management criteria]
+[Velocity tracking, burndown metrics, and team performance indicators]
 
-## Cybersecurity Specific Recommendations
-[Role-specific security controls and threat mitigation strategies]
+## Scrum Master Specific Recommendations
+[Role-specific agile process optimization and team facilitation strategies]
 
 ---
-*Generated by security-expert analysis addressing structured framework*
+*Generated by scrum-master analysis addressing structured framework*
 ```
 
 ## 🔄 **Session Integration**
@@ -190,10 +190,10 @@ TodoWrite({
 ### Completion Status Update
 ```json
 {
-  "security_expert": {
+  "scrum_master": {
     "status": "completed",
     "framework_addressed": true,
-    "output_location": ".workflow/WFS-{session}/.brainstorming/security-expert/analysis.md",
+    "output_location": ".workflow/WFS-{session}/.brainstorming/scrum-master/analysis.md",
     "framework_reference": "@../topic-framework.md"
   }
 }
@@ -201,5 +201,5 @@ TodoWrite({
 
 ### Integration Points
 - **Framework Reference**: @../topic-framework.md for structured discussion points
-- **Cross-Role Synthesis**: Security insights available for synthesis-report.md integration
-- **Agent Autonomy**: Independent execution with framework guidance
+- **Cross-Role Synthesis**: Agile process insights available for synthesis-report.md integration
+- **Agent Autonomy**: Independent execution with framework guidance

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

@@ -0,0 +1,205 @@
+---
+name: subject-matter-expert
+description: Generate or update subject-matter-expert/analysis.md addressing topic-framework discussion points
+usage: /workflow:brainstorm:subject-matter-expert [topic]
+argument-hint: "optional topic - uses existing framework if available"
+examples:
+  - /workflow:brainstorm:subject-matter-expert
+  - /workflow:brainstorm:subject-matter-expert "user authentication redesign"
+  - /workflow:brainstorm:subject-matter-expert "mobile app performance optimization"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
+---
+
+## 🎯 **Subject Matter Expert Analysis Generator**
+
+### Purpose
+**Specialized command for generating subject-matter-expert/analysis.md** that addresses topic-framework.md discussion points from domain knowledge and technical expertise perspective. Creates or updates role-specific analysis with framework references.
+
+### Core Function
+- **Framework-based Analysis**: Address each discussion point in topic-framework.md
+- **Domain Expertise Focus**: Deep technical knowledge, industry standards, and best practices
+- **Update Mechanism**: Create new or update existing analysis.md
+- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
+
+### Analysis Scope
+- **Domain Knowledge**: Industry-specific expertise, regulatory requirements, and compliance
+- **Technical Standards**: Best practices, design patterns, and architectural guidelines
+- **Risk Assessment**: Technical debt, scalability concerns, and maintenance implications
+- **Knowledge Transfer**: Documentation strategies, training requirements, and expertise sharing
+
+## ⚙️ **Execution Protocol**
+
+### Phase 1: Session & Framework Detection
+```bash
+# Check active session and framework
+CHECK: .workflow/.active-* marker files
+IF active_session EXISTS:
+    session_id = get_active_session()
+    brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+
+    CHECK: brainstorm_dir/topic-framework.md
+    IF EXISTS:
+        framework_mode = true
+        load_framework = true
+    ELSE:
+        IF topic_provided:
+            framework_mode = false  # Create analysis without framework
+        ELSE:
+            ERROR: "No framework found and no topic provided"
+```
+
+### Phase 2: Analysis Mode Detection
+```bash
+# Determine execution mode
+IF framework_mode == true:
+    mode = "framework_based_analysis"
+    topic_ref = load_framework_topic()
+    discussion_points = extract_framework_points()
+ELSE:
+    mode = "standalone_analysis"
+    topic_ref = provided_topic
+    discussion_points = generate_basic_structure()
+```
+
+### Phase 3: Agent Execution with Flow Control
+**Framework-Based Analysis Generation**
+
+```bash
+Task(conceptual-planning-agent): "
+[FLOW_CONTROL]
+
+Execute subject-matter-expert analysis for existing topic framework
+
+## Context Loading
+ASSIGNED_ROLE: subject-matter-expert
+OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/subject-matter-expert/
+ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
+
+## Flow Control Steps
+1. **load_topic_framework**
+   - Action: Load structured topic discussion framework
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
+   - Output: topic_framework_content
+
+2. **load_role_template**
+   - Action: Load subject-matter-expert planning template
+   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/subject-matter-expert.md))
+   - Output: role_template_guidelines
+
+3. **load_session_metadata**
+   - Action: Load session metadata and existing context
+   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
+   - Output: session_context
+
+## Analysis Requirements
+**Framework Reference**: Address all discussion points in topic-framework.md from domain expertise and technical standards perspective
+**Role Focus**: Domain knowledge, technical standards, risk assessment, knowledge transfer
+**Structured Approach**: Create analysis.md addressing framework discussion points
+**Template Integration**: Apply role template guidelines within framework structure
+
+## Expected Deliverables
+1. **analysis.md**: Comprehensive domain expertise analysis addressing all framework discussion points
+2. **Framework Reference**: Include @../topic-framework.md reference in analysis
+
+## Completion Criteria
+- Address each discussion point from topic-framework.md with subject matter expertise
+- Provide actionable technical standards and best practices recommendations
+- Include risk assessment and compliance considerations
+- Reference framework document using @ notation for integration
+"
+```
+
+## 📋 **TodoWrite Integration**
+
+### Workflow Progress Tracking
+```javascript
+TodoWrite({
+  todos: [
+    {
+      content: "Detect active session and locate topic framework",
+      status: "in_progress",
+      activeForm: "Detecting session and framework"
+    },
+    {
+      content: "Load topic-framework.md and session metadata for context",
+      status: "pending",
+      activeForm: "Loading framework and session context"
+    },
+    {
+      content: "Execute subject-matter-expert analysis using conceptual-planning-agent with FLOW_CONTROL",
+      status: "pending",
+      activeForm: "Executing subject-matter-expert framework analysis"
+    },
+    {
+      content: "Generate analysis.md addressing all framework discussion points",
+      status: "pending",
+      activeForm: "Generating structured subject-matter-expert analysis"
+    },
+    {
+      content: "Update workflow-session.json with subject-matter-expert completion status",
+      status: "pending",
+      activeForm: "Updating session metadata"
+    }
+  ]
+});
+```
+
+## 📊 **Output Structure**
+
+### Framework-Based Analysis
+```
+.workflow/WFS-{session}/.brainstorming/subject-matter-expert/
+└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+```
+
+### Analysis Document Structure
+```markdown
+# Subject Matter Expert Analysis: [Topic from Framework]
+
+## Framework Reference
+**Topic Framework**: @../topic-framework.md
+**Role Focus**: Domain Expertise & Technical Standards perspective
+
+## Discussion Points Analysis
+[Address each point from topic-framework.md with subject matter expertise]
+
+### Core Requirements (from framework)
+[Domain-specific requirements and industry standards perspective]
+
+### Technical Considerations (from framework)
+[Deep technical analysis, architectural patterns, and best practices]
+
+### User Experience Factors (from framework)
+[Domain-specific usability standards and industry conventions]
+
+### Implementation Challenges (from framework)
+[Technical risks, scalability concerns, and maintenance implications]
+
+### Success Metrics (from framework)
+[Domain-specific KPIs, compliance metrics, and quality standards]
+
+## Subject Matter Expert Specific Recommendations
+[Role-specific technical expertise and industry best practices]
+
+---
+*Generated by subject-matter-expert analysis addressing structured framework*
+```
+
+## 🔄 **Session Integration**
+
+### Completion Status Update
+```json
+{
+  "subject_matter_expert": {
+    "status": "completed",
+    "framework_addressed": true,
+    "output_location": ".workflow/WFS-{session}/.brainstorming/subject-matter-expert/analysis.md",
+    "framework_reference": "@../topic-framework.md"
+  }
+}
+```
+
+### Integration Points
+- **Framework Reference**: @../topic-framework.md for structured discussion points
+- **Cross-Role Synthesis**: Domain expertise insights available for synthesis-report.md integration
+- **Agent Autonomy**: Independent execution with framework guidance

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

@@ -184,7 +184,7 @@ Strategic overview with key insights, breakthrough opportunities, and implementa
 
 ## Design Specifications
 ### UI/UX Guidelines
-**Consolidated from**: @ui-designer/analysis.md, @user-researcher/analysis.md
+**Consolidated from**: @ui-designer/analysis.md, @ux-expert/analysis.md
 - Component specifications and interaction patterns
 - Visual design system and accessibility requirements
 - User flow and interface specifications
@@ -195,11 +195,11 @@ Strategic overview with key insights, breakthrough opportunities, and implementa
 - Data flow and storage strategy
 - Technology stack decisions
 
-### Security Framework
-**Consolidated from**: @security-expert/analysis.md
-- Authentication and authorization patterns
-- Data protection and compliance requirements
-- Security monitoring and audit strategy
+### Domain Expertise & Standards
+**Consolidated from**: @subject-matter-expert/analysis.md
+- Industry standards and best practices
+- Compliance requirements and regulations
+- Technical quality and domain-specific patterns
 
 ## Implementation Roadmap
 ### Development Phases
@@ -242,7 +242,7 @@ Upon completion, update `workflow-session.json`:
       "status": "completed",
       "synthesis_completed": true,
       "completed_at": "timestamp",
-      "participating_roles": ["product-manager", "system-architect", "ui-designer", "security-expert", "data-architect", ...],
+      "participating_roles": ["product-manager", "product-owner", "scrum-master", "system-architect", "ui-designer", "ux-expert", "data-architect", "subject-matter-expert", "test-strategist"],
       "consolidated_output": {
         "synthesis_specification": ".workflow/WFS-{topic}/.brainstorming/synthesis-specification.md"
       },

.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/user-researcher.md

@@ -1,267 +0,0 @@
----
-name: user-researcher
-description: User researcher perspective brainstorming for user behavior analysis and research insights
-usage: /workflow:brainstorm:user-researcher <topic>
-argument-hint: "topic or challenge to analyze from user research perspective"
-examples:
-  - /workflow:brainstorm:user-researcher "user onboarding experience"
-  - /workflow:brainstorm:user-researcher "mobile app usability issues"
-  - /workflow:brainstorm:user-researcher "feature adoption analysis"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*)
----
-
-## 🔍 **Role Overview: User Researcher**
-
-### Role Definition
-User experience research specialist responsible for understanding user behavior, identifying needs and pain points, and transforming research insights into actionable product improvements that enhance user satisfaction and engagement.
-
-### Core Responsibilities
-- **User Behavior Research**: Deep analysis of user behavior patterns and motivations
-- **User Needs Discovery**: Research to discover unmet user needs and requirements
-- **Usability Assessment**: Evaluate product usability and user experience issues
-- **User Insights Generation**: Transform research findings into actionable product insights
-
-### Focus Areas
-- **User Behavior**: Usage patterns, decision paths, task completion methods
-- **User Needs**: Explicit needs, implicit needs, emotional requirements
-- **User Experience**: Pain points, satisfaction levels, emotional responses, expectations
-- **Market Segmentation**: User personas, demographic segments, usage scenarios
-
-### Success Metrics
-- User satisfaction and engagement scores
-- Task success rates and completion times
-- Quality and actionability of research insights
-- Impact of research on product decisions
-
-## 🧠 **分析框架**
-
-@~/.claude/workflows/brainstorming-principles.md
-
-### Key Analysis Questions
-
-**1. User Understanding and Insights**
-- What are the real needs and pain points of target users?
-- What are the user behavior patterns and usage scenarios?
-- What are the differentiated needs of various user groups?
-
-**2. User Experience Analysis**
-- What are the main issues with the current user experience?
-- What obstacles and friction points exist in user task completion?
-- What gaps exist between user satisfaction and expectations?
-
-**3. Research Methods and Validation**
-- Which research methods are most suitable for the current problem?
-- How can hypotheses and design decisions be validated?
-- How can continuous user feedback be collected?
-
-**4. Insights Translation and Application**
-- How can research findings be translated into product improvements?
-- How can product decisions and design be influenced?
-- How can a user-centered culture be established?
-
-## ⚡ **Two-Step Execution Flow**
-
-### ⚠️ Session Management - FIRST STEP
-Session detection and selection:
-```bash
-# Check for active sessions
-active_sessions=$(find .workflow -name ".active-*" 2>/dev/null)
-if [ multiple_sessions ]; then
-  prompt_user_to_select_session()
-else
-  use_existing_or_create_new()
-fi
-```
-
-### Step 1: Context Gathering Phase
-**User Researcher Perspective Questioning**
-
-Before agent assignment, gather comprehensive user researcher context:
-
-#### 📋 Role-Specific Questions
-
-**1. User Behavior Patterns and Insights**
-- Who are the primary users and what are their key characteristics?
-- What user behaviors, patterns, or pain points have you observed?
-- Are there specific user segments or personas you're particularly interested in?
-- What user feedback or data do you already have available?
-
-**2. Research Focus and Pain Points**
-- What specific user experience problems or questions need to be addressed?
-- Are there particular user tasks, workflows, or touchpoints to focus on?
-- What assumptions about users need to be validated or challenged?
-- What gaps exist in your current understanding of user needs?
-
-**3. Research Context and Constraints**
-- What research has been done previously and what were the key findings?
-- Are there specific research methods you prefer or want to avoid?
-- What timeline and resources are available for user research?
-- Who are the key stakeholders that need to understand user insights?
-
-**4. User Testing Strategy and Goals**
-- What specific user experience improvements are you hoping to achieve?
-- How do you currently measure user satisfaction or success?
-- Are there competitive products or experiences you want to benchmark against?
-- What would successful user research outcomes look like for this project?
-
-#### Context Validation
-- **Minimum Response**: Each answer must be ≥50 characters
-- **Re-prompting**: Insufficient detail triggers follow-up questions
-- **Context Storage**: Save responses to `.brainstorming/user-researcher-context.md`
-
-### Step 2: Agent Assignment with Flow Control
-**Dedicated Agent Execution**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute dedicated user researcher conceptual analysis for: {topic}
-
-ASSIGNED_ROLE: user-researcher
-OUTPUT_LOCATION: .brainstorming/user-researcher/
-USER_CONTEXT: {validated_responses_from_context_gathering}
-
-Flow Control Steps:
-[
-  {
-    \"step\": \"load_role_template\",
-    \"action\": \"Load user-researcher planning template\",
-    \"command\": \"bash($(cat ~/.claude/workflows/cli-templates/planning-roles/user-researcher.md))\",
-    \"output_to\": \"role_template\"
-  }
-]
-
-Conceptual Analysis Requirements:
-- Apply user researcher perspective to topic analysis
-- Focus on user behavior patterns, pain points, research insights, and user testing strategy
-- Use loaded role template framework for analysis structure
-- Generate role-specific deliverables in designated output location
-- Address all user context from questioning phase
-
-Deliverables:
-- analysis.md: Main user researcher analysis
-- recommendations.md: User researcher recommendations
-- deliverables/: User researcher-specific outputs as defined in role template
-
-Embody user researcher role expertise for comprehensive conceptual planning."
-```
-
-### Progress Tracking
-TodoWrite tracking for two-step process:
-```json
-[
-  {"content": "Gather user researcher context through role-specific questioning", "status": "in_progress", "activeForm": "Gathering context"},
-  {"content": "Validate context responses and save to user-researcher-context.md", "status": "pending", "activeForm": "Validating context"},
-  {"content": "Load user-researcher planning template via flow control", "status": "pending", "activeForm": "Loading template"},
-  {"content": "Execute dedicated conceptual-planning-agent for user-researcher role", "status": "pending", "activeForm": "Executing agent"}
-]
-```
-
-## 📊 **输出结构**
-
-### 保存位置
-```
-.workflow/WFS-{topic-slug}/.brainstorming/user-researcher/
-├── analysis.md                     # 主要用户研究分析
-├── user-personas.md                # 详细用户画像和细分
-├── research-plan.md                # 方法论和研究方法
-└── insights-recommendations.md     # 关键发现和可执行建议
-```
-
-### 文档模板
-
-#### analysis.md 结构
-```markdown
-# User Researcher Analysis: {Topic}
-*Generated: {timestamp}*
-
-## Executive Summary
-[核心用户研究发现和建议概述]
-
-## Current User Landscape
-### User Base Overview
-### Behavioral Patterns
-### Usage Statistics and Trends
-### Satisfaction Metrics
-
-## User Needs Analysis
-### Primary User Needs
-### Unmet Needs and Gaps
-### Need Prioritization Matrix
-### Emotional and Functional Needs
-
-## User Experience Assessment
-### Current UX Strengths
-### Major Pain Points and Friction
-### Usability Issues Identified
-### Accessibility Gaps
-
-## User Behavior Insights
-### User Journey Mapping
-### Decision-Making Patterns
-### Task Completion Analysis
-### Behavioral Segments
-
-## Research Recommendations
-### Recommended Research Methods
-### Key Research Questions
-### Success Metrics and KPIs
-### Research Timeline and Resources
-
-## Actionable Insights
-### Immediate UX Improvements
-### Product Feature Recommendations
-### Long-term User Strategy
-### Success Measurement Plan
-```
-
-## 🔄 **会话集成**
-
-### 状态同步
-分析完成后，更新 `workflow-session.json`:
-```json
-{
-  "phases": {
-    "BRAINSTORM": {
-      "user_researcher": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/user-researcher/",
-        "key_insights": ["user_behavior_pattern", "unmet_need", "usability_issue"]
-      }
-    }
-  }
-}
-```
-
-### 与其他角色的协作
-用户研究员视角为其他角色提供：
-- **用户需求和洞察** → Product Manager
-- **用户行为数据** → Data Architect
-- **用户体验要求** → UI Designer
-- **用户安全需求** → Security Expert
-- **功能使用场景** → Feature Planner
-
-## ✅ **质量标准**
-
-### 必须包含的研究元素
-- [ ] 详细的用户行为分析
-- [ ] 明确的用户需求识别
-- [ ] 全面的用户体验评估
-- [ ] 科学的研究方法设计
-- [ ] 可执行的改进建议
-
-### 用户研究原则检查
-- [ ] 以人为本：所有分析以用户为中心
-- [ ] 基于证据：结论有数据和研究支撑
-- [ ] 行为导向：关注实际行为而非声明意图
-- [ ] 情境考虑：分析使用场景和环境因素
-- [ ] 持续迭代：建立持续研究和改进机制
-
-### 洞察质量评估
-- [ ] 洞察的新颖性和深度
-- [ ] 建议的可操作性和具体性
-- [ ] 影响评估的准确性
-- [ ] 研究方法的科学性
-- [ ] 用户代表性的覆盖度

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

@@ -1,31 +1,31 @@
 ---
-name: feature-planner
-description: Generate or update feature-planner/analysis.md addressing topic-framework discussion points
-usage: /workflow:brainstorm:feature-planner [topic]
+name: ux-expert
+description: Generate or update ux-expert/analysis.md addressing topic-framework discussion points
+usage: /workflow:brainstorm:ux-expert [topic]
 argument-hint: "optional topic - uses existing framework if available"
 examples:
-  - /workflow:brainstorm:feature-planner
-  - /workflow:brainstorm:feature-planner "user dashboard enhancement"
-  - /workflow:brainstorm:feature-planner "mobile app feature roadmap"
+  - /workflow:brainstorm:ux-expert
+  - /workflow:brainstorm:ux-expert "user authentication redesign"
+  - /workflow:brainstorm:ux-expert "mobile app performance optimization"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
 
-## 🔧 **Feature Planner Analysis Generator**
+## 🎯 **UX Expert Analysis Generator**
 
 ### Purpose
-**Specialized command for generating feature-planner/analysis.md** that addresses topic-framework.md discussion points from feature development perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating ux-expert/analysis.md** that addresses topic-framework.md discussion points from user experience and interface design perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
 - **Framework-based Analysis**: Address each discussion point in topic-framework.md
-- **Feature Development Focus**: Feature specification, development planning, and delivery management
+- **UX Design Focus**: User interface, interaction patterns, and usability optimization
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
 
 ### Analysis Scope
-- **Feature Specification**: Transform requirements into detailed specifications
-- **Development Planning**: Sprint planning, milestones, and dependency management
-- **Quality Assurance**: Testing strategies and acceptance criteria
-- **Delivery Management**: Release planning and implementation timelines
+- **User Interface Design**: Visual hierarchy, layout patterns, and component design
+- **Interaction Patterns**: User flows, navigation, and microinteractions
+- **Usability Optimization**: Accessibility, cognitive load, and user testing strategies
+- **Design Systems**: Component libraries, design tokens, and consistency frameworks
 
 ## ⚙️ **Execution Protocol**
 
@@ -68,11 +68,11 @@ ELSE:
 Task(conceptual-planning-agent): "
 [FLOW_CONTROL]
 
-Execute feature-planner analysis for existing topic framework
+Execute ux-expert analysis for existing topic framework
 
 ## Context Loading
-ASSIGNED_ROLE: feature-planner
-OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/feature-planner/
+ASSIGNED_ROLE: ux-expert
+OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/ux-expert/
 ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 ## Flow Control Steps
@@ -82,29 +82,29 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
    - Output: topic_framework_content
 
 2. **load_role_template**
-   - Action: Load feature-planner planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/feature-planner.md))
+   - Action: Load ux-expert planning template
+   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/ux-expert.md))
    - Output: role_template_guidelines
 
 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
-**Framework Reference**: Address all discussion points in topic-framework.md from feature development perspective
-**Role Focus**: Feature specification, development planning, quality assurance, delivery management
+**Framework Reference**: Address all discussion points in topic-framework.md from user experience and interface design perspective
+**Role Focus**: UI design, interaction patterns, usability optimization, design systems
 **Structured Approach**: Create analysis.md addressing framework discussion points
 **Template Integration**: Apply role template guidelines within framework structure
 
 ## Expected Deliverables
-1. **analysis.md**: Comprehensive feature planning analysis addressing all framework discussion points
+1. **analysis.md**: Comprehensive UX design analysis addressing all framework discussion points
 2. **Framework Reference**: Include @../topic-framework.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with feature development expertise
-- Provide actionable development plans and implementation strategies
-- Include quality assurance and testing considerations
+- Address each discussion point from topic-framework.md with UX design expertise
+- Provide actionable interface design and usability optimization strategies
+- Include accessibility considerations and interaction pattern recommendations
 - Reference framework document using @ notation for integration
 "
 ```
@@ -126,17 +126,17 @@ TodoWrite({
       activeForm: "Loading framework and session context"
     },
     {
-      content: "Execute feature-planner analysis using conceptual-planning-agent with FLOW_CONTROL",
+      content: "Execute ux-expert analysis using conceptual-planning-agent with FLOW_CONTROL",
       status: "pending",
-      activeForm: "Executing feature-planner framework analysis"
+      activeForm: "Executing ux-expert framework analysis"
     },
     {
       content: "Generate analysis.md addressing all framework discussion points",
       status: "pending",
-      activeForm: "Generating structured feature-planner analysis"
+      activeForm: "Generating structured ux-expert analysis"
     },
     {
-      content: "Update session.json with feature-planner completion status",
+      content: "Update workflow-session.json with ux-expert completion status",
       status: "pending",
       activeForm: "Updating session metadata"
     }
@@ -148,41 +148,41 @@ TodoWrite({
 
 ### Framework-Based Analysis
 ```
-.workflow/WFS-{session}/.brainstorming/feature-planner/
+.workflow/WFS-{session}/.brainstorming/ux-expert/
 └── analysis.md    # Structured analysis addressing topic-framework.md discussion points
 ```
 
 ### Analysis Document Structure
 ```markdown
-# Feature Planner Analysis: [Topic from Framework]
+# UX Expert Analysis: [Topic from Framework]
 
 ## Framework Reference
 **Topic Framework**: @../topic-framework.md
-**Role Focus**: Feature Development perspective
+**Role Focus**: User Experience & Interface Design perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with feature development expertise]
+[Address each point from topic-framework.md with UX design expertise]
 
 ### Core Requirements (from framework)
-[Feature development perspective on requirements]
+[User interface and interaction design requirements perspective]
 
 ### Technical Considerations (from framework)
-[Feature architecture and development considerations]
+[Design system implementation and technical feasibility considerations]
 
 ### User Experience Factors (from framework)
-[Feature usability and user story considerations]
+[Usability optimization, accessibility, and user-centered design analysis]
 
 ### Implementation Challenges (from framework)
-[Development complexity and delivery considerations]
+[Design implementation challenges and progressive enhancement strategies]
 
 ### Success Metrics (from framework)
-[Feature success metrics and acceptance criteria]
+[UX metrics including usability testing, user satisfaction, and design KPIs]
 
-## Feature Development Specific Recommendations
-[Role-specific feature planning recommendations and strategies]
+## UX Expert Specific Recommendations
+[Role-specific interface design patterns and usability optimization strategies]
 
 ---
-*Generated by feature-planner analysis addressing structured framework*
+*Generated by ux-expert analysis addressing structured framework*
 ```
 
 ## 🔄 **Session Integration**
@@ -190,10 +190,10 @@ TodoWrite({
 ### Completion Status Update
 ```json
 {
-  "feature_planner": {
+  "ux_expert": {
     "status": "completed",
     "framework_addressed": true,
-    "output_location": ".workflow/WFS-{session}/.brainstorming/feature-planner/analysis.md",
+    "output_location": ".workflow/WFS-{session}/.brainstorming/ux-expert/analysis.md",
     "framework_reference": "@../topic-framework.md"
   }
 }
@@ -201,5 +201,5 @@ TodoWrite({
 
 ### Integration Points
 - **Framework Reference**: @../topic-framework.md for structured discussion points
-- **Cross-Role Synthesis**: Feature development insights available for synthesis-report.md integration
-- **Agent Autonomy**: Independent execution with framework guidance
+- **Cross-Role Synthesis**: UX design insights available for synthesis-report.md integration
+- **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/execute.md

@@ -185,9 +185,9 @@ TodoWrite({
       activeForm: "Executing IMPL-1.2: Implement auth logic"
     },
     {
-      content: "Execute IMPL-2: Review implementations [code-review-agent]",
+      content: "Execute TEST-FIX-1: Validate implementation tests [test-fix-agent]",
       status: "pending",
-      activeForm: "Executing IMPL-2: Review implementations"
+      activeForm: "Executing TEST-FIX-1: Validate implementation tests"
     }
   ]
 });
@@ -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)
-     completed_tasks=\$(ls .workflow/*/\.summaries/*.md 2>/dev/null | wc -l)
+     total_tasks=\$(find .workflow/*/\.task/ -name "*.json" -type f 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"),
@@ -384,8 +384,8 @@ Task(subagent_type="{meta.agent}",
   "title": "Task title",
   "status": "pending|active|completed|blocked",
   "meta": {
-    "type": "feature|bugfix|refactor|test|docs",
-    "agent": "@code-developer|@planning-agent|@code-review-test-agent"
+    "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
+    "agent": "@code-developer|@test-fix-agent|@general-purpose"
   },
   "context": {
     "requirements": ["req1", "req2"],
@@ -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"]
   }
 }
 ```
@@ -451,8 +451,9 @@ Task(subagent_type="{meta.agent}",
 meta.agent specified → Use specified agent
 meta.agent missing → Infer from meta.type:
   - "feature" → @code-developer
-  - "test" → @code-review-test-agent
-  - "review" → @code-review-agent
+  - "test-gen" → @code-developer
+  - "test-fix" → @test-fix-agent
+  - "review" → @general-purpose
   - "docs" → @doc-generator
 ```
 

.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**:
-1. Initialize TodoWrite → Execute Phase 1 → Parse output → Update TodoWrite
-2. Execute Phase 2 with Phase 1 data → Parse output → Update TodoWrite
-3. Execute Phase 3 with Phase 2 data → Parse output → Update TodoWrite
-4. Execute Phase 4 with Phase 3 validation → Update TodoWrite → Return summary
+**Execution Model - Auto-Continue Workflow**:
+
+Each phase executes and returns to user, then **automatically continues** to next phase:
+
+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
-5. **Complete All Phases**: Do not return to user until Phase 4 completes
-6. **Track Progress**: Update TodoWrite after every phase completion
+4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
+5. **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

@@ -1,85 +1,272 @@
 ---
 name: review
-description: Execute review phase for quality validation
-usage: /workflow:review
-argument-hint: none
+description: Optional specialized review (security, architecture, docs) for completed implementation
+usage: /workflow:review [--type=<type>] [session-id]
+argument-hint: "[--type=security|architecture|action-items|quality] [session-id]"
 examples:
-  - /workflow:review
+  - /workflow:review                           # Quality review of active session
+  - /workflow:review --type=security           # Security audit of active session
+  - /workflow:review --type=architecture WFS-user-auth  # Architecture review of specific session
+  - /workflow:review --type=action-items       # Pre-deployment verification
 ---
 
-# Workflow Review Command (/workflow:review)
+### 🚀 Command Overview: `/workflow:review`
 
-## Overview
-Final phase for quality validation, testing, and completion.
+**Optional specialized review** for completed implementations. In the standard workflow, **passing tests = approved code**. Use this command only when specialized review is required (security, architecture, compliance, docs).
 
-## Core Principles
-**Session Management:** @~/.claude/workflows/workflow-architecture.md
+## Philosophy: "Tests Are the Review"
 
-## Review Process
+- ✅ **Default**: All tests pass → Code approved
+- 🔍 **Optional**: Specialized reviews for:
+  - 🔒 Security audits (vulnerabilities, auth/authz)
+  - 🏗️ Architecture compliance (patterns, technical debt)
+  - 📋 Action items verification (requirements met, acceptance criteria)
 
-1. **Validation Checks**
-   - All tasks completed
-   - Tests passing
-   - Code quality metrics
-   - Documentation complete
+## Review Types
 
-2. **Generate Review Report**
+| Type | Focus | Use Case |
+|------|-------|----------|
+| `quality` | Code quality, best practices, maintainability | Default general review |
+| `security` | Security vulnerabilities, data handling, access control | Security audits |
+| `architecture` | Architectural patterns, technical debt, design decisions | Architecture compliance |
+| `action-items` | Requirements met, acceptance criteria verified, action items completed | Pre-deployment verification |
+
+**Notes**:
+- For documentation generation, use `/workflow:tools:docs`
+- For CLAUDE.md updates, use `/update-memory-related`
+
+## Execution Template
+
+```bash
+#!/bin/bash
+# Optional specialized review for completed implementation
+
+# Step 1: Session ID resolution
+if [ -n "$SESSION_ARG" ]; then
+    sessionId="$SESSION_ARG"
+else
+    sessionId=$(find .workflow/ -name '.active-*' | head -1 | sed 's/.*active-//')
+fi
+
+# Step 2: Validation
+if [ ! -d ".workflow/${sessionId}" ]; then
+    echo "❌ Session ${sessionId} not found"
+    exit 1
+fi
+
+# Check for completed tasks
+if [ ! -d ".workflow/${sessionId}/.summaries" ] || [ -z "$(find .workflow/${sessionId}/.summaries/ -name "IMPL-*.md" -type f 2>/dev/null)" ]; then
+    echo "❌ No completed implementation found. Complete implementation first"
+    exit 1
+fi
+
+# Step 3: Determine review type (default: quality)
+review_type="${TYPE_ARG:-quality}"
+
+# Redirect docs review to specialized command
+if [ "$review_type" = "docs" ]; then
+    echo "💡 For documentation generation, please use:"
+    echo "   /workflow:tools:docs"
+    echo ""
+    echo "The docs command provides:"
+    echo "  - Hierarchical architecture documentation"
+    echo "  - API documentation generation"
+    echo "  - Documentation structure analysis"
+    exit 0
+fi
+
+# Step 4: Analysis handover → Model takes control
+# BASH_EXECUTION_STOPS → MODEL_ANALYSIS_BEGINS
+```
+
+### 🧠 Model Analysis Phase
+
+After bash validation, the model takes control to:
+
+1. **Load Context**: Read completed task summaries and changed files
+   ```bash
+   # Load implementation summaries
+   cat .workflow/${sessionId}/.summaries/IMPL-*.md
+
+   # Load test results (if available)
+   cat .workflow/${sessionId}/.summaries/TEST-FIX-*.md 2>/dev/null
+
+   # Get changed files
+   git log --since="$(cat .workflow/${sessionId}/workflow-session.json | jq -r .created_at)" --name-only --pretty=format: | sort -u
+   ```
+
+2. **Perform Specialized Review**: Based on `review_type`
+
+   **Security Review** (`--type=security`):
+   - Use MCP code search for security patterns:
+     ```bash
+     mcp__code-index__search_code_advanced(pattern="password|token|secret|auth", file_pattern="*.{ts,js,py}")
+     mcp__code-index__search_code_advanced(pattern="eval|exec|innerHTML|dangerouslySetInnerHTML", file_pattern="*.{ts,js,tsx}")
+     ```
+   - Use Gemini for security analysis:
+     ```bash
+     cd .workflow/${sessionId} && ~/.claude/scripts/gemini-wrapper -p "
+     PURPOSE: Security audit of completed implementation
+     TASK: Review code for security vulnerabilities, insecure patterns, auth/authz issues
+     CONTEXT: @{.summaries/IMPL-*.md,../..,../../CLAUDE.md}
+     EXPECTED: Security findings report with severity levels
+     RULES: Focus on OWASP Top 10, authentication, authorization, data validation, injection risks
+     " --approval-mode yolo
+     ```
+
+   **Architecture Review** (`--type=architecture`):
+   - Use Qwen for architecture analysis:
+     ```bash
+     cd .workflow/${sessionId} && ~/.claude/scripts/qwen-wrapper -p "
+     PURPOSE: Architecture compliance review
+     TASK: Evaluate adherence to architectural patterns, identify technical debt, review design decisions
+     CONTEXT: @{.summaries/IMPL-*.md,../..,../../CLAUDE.md}
+     EXPECTED: Architecture assessment with recommendations
+     RULES: Check for patterns, separation of concerns, modularity, scalability
+     " --approval-mode yolo
+     ```
+
+   **Quality Review** (`--type=quality`):
+   - Use Gemini for code quality:
+     ```bash
+     cd .workflow/${sessionId} && ~/.claude/scripts/gemini-wrapper -p "
+     PURPOSE: Code quality and best practices review
+     TASK: Assess code readability, maintainability, adherence to best practices
+     CONTEXT: @{.summaries/IMPL-*.md,../..,../../CLAUDE.md}
+     EXPECTED: Quality assessment with improvement suggestions
+     RULES: Check for code smells, duplication, complexity, naming conventions
+     " --approval-mode yolo
+     ```
+
+   **Action Items Review** (`--type=action-items`):
+   - Verify all requirements and acceptance criteria met:
+     ```bash
+     # Load task requirements and acceptance criteria
+     find .workflow/${sessionId}/.task -name "IMPL-*.json" -exec jq -r '
+       "Task: " + .id + "\n" +
+       "Requirements: " + (.context.requirements | join(", ")) + "\n" +
+       "Acceptance: " + (.context.acceptance | join(", "))
+     ' {} \;
+
+     # Check implementation summaries against requirements
+     cd .workflow/${sessionId} && ~/.claude/scripts/gemini-wrapper -p "
+     PURPOSE: Verify all requirements and acceptance criteria are met
+     TASK: Cross-check implementation summaries against original requirements
+     CONTEXT: @{.task/IMPL-*.json,.summaries/IMPL-*.md,../..,../../CLAUDE.md}
+     EXPECTED:
+     - Requirements coverage matrix
+     - Acceptance criteria verification
+     - Missing/incomplete action items
+     - Pre-deployment readiness assessment
+     RULES:
+     - Check each requirement has corresponding implementation
+     - Verify all acceptance criteria are met
+     - Flag any incomplete or missing action items
+     - Assess deployment readiness
+     " --approval-mode yolo
+     ```
+
+
+3. **Generate Review Report**: Create structured report
    ```markdown
-   # Review Report
-   
-   ## Task Completion
-   - Total: 10
-   - Completed: 10
-   - Success Rate: 100%
-   
-   ## Quality Metrics
-   - Test Coverage: 85%
-   - Code Quality: A
-   - Documentation: Complete
-   
-   ## Issues Found
-   - Minor: 2
-   - Major: 0
-   - Critical: 0
+   # Review Report: ${review_type}
+
+   **Session**: ${sessionId}
+   **Date**: $(date)
+   **Type**: ${review_type}
+
+   ## Summary
+   - Tasks Reviewed: [count IMPL tasks]
+   - Files Changed: [count files]
+   - Severity: [High/Medium/Low]
+
+   ## Findings
+
+   ### Critical Issues
+   - [Issue 1 with file:line reference]
+   - [Issue 2 with file:line reference]
+
+   ### Recommendations
+   - [Recommendation 1]
+   - [Recommendation 2]
+
+   ### Positive Observations
+   - [Good pattern observed]
+
+   ## Action Items
+   - [ ] [Action 1]
+   - [ ] [Action 2]
    ```
 
-3. **Update Session**
-   ```json
-   {
-     "current_phase": "REVIEW",
-     "phases": {
-       "REVIEW": {
-         "status": "completed",
-         "output": "REVIEW.md",
-         "test_results": {
-           "passed": 45,
-           "failed": 0,
-           "coverage": 85
-         }
-       }
-     }
-   }
+4. **Output Files**:
+   ```bash
+   # Save review report
+   Write(.workflow/${sessionId}/REVIEW-${review_type}.md)
+
+   # Update session metadata
+   # (optional) Update workflow-session.json with review status
    ```
 
-## Auto-fix (Default)
-Auto-fix is enabled by default:
-- Automatically fixes minor issues
-- Runs formatters and linters
-- Updates documentation
-- Re-runs tests
+5. **Optional: Update Memory** (if docs review or significant findings):
+   ```bash
+   # If architecture or quality issues found, suggest memory update
+   if [ "$review_type" = "architecture" ] || [ "$review_type" = "quality" ]; then
+       echo "💡 Consider updating project documentation:"
+       echo "   /update-memory-related"
+   fi
+   ```
 
-## Completion Criteria
-- All tasks marked complete
-- Tests passing (configurable threshold)
-- No critical issues
-- Documentation updated
+## Usage Examples
 
-## Output Files
-- `REVIEW.md` - Review report
-- `workflow-session.json` - Updated with results
-- `test-results.json` - Detailed test output
+```bash
+# General quality review after implementation
+/workflow:review
+
+# Security audit before deployment
+/workflow:review --type=security
+
+# Architecture review for specific session
+/workflow:review --type=architecture WFS-payment-integration
+
+# Documentation review
+/workflow:review --type=docs
+```
+
+## ✨ Features
+
+- **Simple Validation**: Check session exists and has completed tasks
+- **No Complex Orchestration**: Direct analysis, no multi-phase pipeline
+- **Specialized Reviews**: Different prompts and tools for different review types
+- **MCP Integration**: Fast code search for security and architecture patterns
+- **CLI Tool Integration**: Gemini for analysis, Qwen for architecture
+- **Structured Output**: Markdown reports with severity levels and action items
+- **Optional Memory Update**: Suggests documentation updates for significant findings
+
+## Integration with Workflow
+
+```
+Standard Workflow:
+  plan → execute → test-gen → execute ✅
+
+Optional Review (when needed):
+  plan → execute → test-gen → execute → review (security/architecture/docs)
+```
+
+**When to Use**:
+- Before production deployment (security review + action-items review)
+- After major feature (architecture review)
+- Before code freeze (quality review)
+- Pre-deployment verification (action-items review)
+
+**When NOT to Use**:
+- Regular development (tests are sufficient)
+- Simple bug fixes (test-fix-agent handles it)
+- Minor changes (update-memory-related is enough)
 
 ## Related Commands
-- `/workflow:execute` - Must complete first
-- `/task:status` - Check task completion
-- `/workflow:status` - View overall status
+
+- `/workflow:execute` - Must complete implementation first
+- `/workflow:test-gen` - Primary quality gate (tests)
+- `/workflow:tools:docs` - Generate hierarchical documentation (use instead of `--type=docs`)
+- `/update-memory-related` - Update CLAUDE.md docs after architecture findings
+- `/workflow:status` - Check session status

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

@@ -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
-ls .workflow/WFS-session/.summaries/*.md 2>/dev/null | wc -l
+find .workflow/WFS-session/.task/ -name "*.json" -type f 2>/dev/null | wc -l
+find .workflow/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
 ```
 
 ### Step 6: Remove Active Marker
@@ -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 completed**: `ls .summaries/*.md | wc -l`
+- **Count tasks**: `find .task/ -name "*.json" -type f | wc -l`
+- **Count completed**: `find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l`
 - **Remove marker**: `rm .workflow/.active-session`
 
 ### Completion Result
@@ -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)
-summary_count=$(ls .summaries/*.md 2>/dev/null | wc -l)
+task_count=$(find .task/ -name "*.json" -type f | wc -l)
+summary_count=$(find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l)
 test $task_count -eq $summary_count || echo "Warning: Not all tasks completed"
 ```
 

.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
-ls .workflow/WFS-session/.summaries/*.md 2>/dev/null | wc -l
+find .workflow/WFS-session/.task/ -name "*.json" -type f 2>/dev/null | wc -l
+find .workflow/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
 ```
 
 ### Step 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-*`
-- **Find active**: `ls .workflow/.active-*`
+- **List sessions**: `find .workflow/ -maxdepth 1 -type d -name "WFS-*"`
+- **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 completed**: `ls .summaries/*.md | wc -l`
+- **Count tasks**: `find .task/ -name "*.json" -type f | 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
-ls .workflow/WFS-session/.summaries/*.md 2>/dev/null | wc -l
+find .workflow/WFS-session/.task/ -name "*.json" -type f | 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
-ls .summaries/*.md | wc -l
+find .task/ -name "*.json" -type f | wc -l
+find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l
 ```
 
 ## Simple Output Format

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

@@ -0,0 +1,133 @@
+---
+name: tdd-plan
+description: Orchestrate TDD workflow planning with Red-Green-Refactor task chains
+usage: /workflow:tdd-plan [--agent] <input>
+argument-hint: "[--agent] \"feature description\"|file.md|ISS-001"
+examples:
+  - /workflow:tdd-plan "Implement user authentication"
+  - /workflow:tdd-plan --agent requirements.md
+  - /workflow:tdd-plan ISS-001
+allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
+---
+
+# TDD Workflow Plan Command (/workflow:tdd-plan)
+
+## Coordinator Role
+
+**This command is a pure orchestrator**: Execute 5 slash commands in sequence, parse outputs, pass context, and ensure complete TDD workflow creation.
+
+**Execution Modes**:
+- **Manual Mode** (default): Use `/workflow:tools:task-generate-tdd`
+- **Agent Mode** (`--agent`): Use `/workflow:tools:task-generate-tdd --agent`
+
+## Core Rules
+
+1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 execution
+2. **No Preliminary Analysis**: Do not read files before Phase 1
+3. **Parse Every Output**: Extract required data for next phase
+4. **Sequential Execution**: Each phase depends on previous output
+5. **Complete All Phases**: Do not return until Phase 5 completes
+6. **TDD Context**: All descriptions include "TDD:" prefix
+
+## 5-Phase Execution
+
+### Phase 1: Session Discovery
+**Command**: `/workflow:session:start --auto "TDD: [structured-description]"`
+
+**TDD Structured Format**:
+```
+TDD: [Feature Name]
+GOAL: [Objective]
+SCOPE: [Included/excluded]
+CONTEXT: [Background]
+TEST_FOCUS: [Test scenarios]
+```
+
+**Parse**: Extract sessionId
+
+### Phase 2: Context Gathering
+**Command**: `/workflow:tools:context-gather --session [sessionId] "TDD: [structured-description]"`
+
+**Parse**: Extract contextPath
+
+### Phase 3: TDD Analysis
+**Command**: `/workflow:tools:concept-enhanced --session [sessionId] --context [contextPath]`
+
+**Parse**: Verify ANALYSIS_RESULTS.md
+
+### Phase 4: TDD Task Generation
+**Command**:
+- Manual: `/workflow:tools:task-generate-tdd --session [sessionId]`
+- Agent: `/workflow:tools:task-generate-tdd --session [sessionId] --agent`
+
+**Parse**: Extract feature count, chain count, task count
+
+**Validate**:
+- TDD_PLAN.md exists
+- IMPL_PLAN.md exists
+- TEST-*.json, IMPL-*.json, REFACTOR-*.json exist
+- TODO_LIST.md exists
+
+### Phase 5: TDD Structure Validation
+**Internal validation (no command)**
+
+**Validate**:
+1. Each feature has TEST → IMPL → REFACTOR chain
+2. Dependencies: IMPL depends_on TEST, REFACTOR depends_on IMPL
+3. Meta fields: tdd_phase correct ("red"/"green"/"refactor")
+4. Agents: TEST uses @code-review-test-agent, IMPL/REFACTOR use @code-developer
+
+**Return Summary**:
+```
+TDD Planning complete for session: [sessionId]
+
+Features analyzed: [N]
+TDD chains generated: [N]
+Total tasks: [3N]
+
+Structure:
+- Feature 1: TEST-1.1 → IMPL-1.1 → REFACTOR-1.1
+[...]
+
+Plans:
+- TDD Structure: .workflow/[sessionId]/TDD_PLAN.md
+- Implementation: .workflow/[sessionId]/IMPL_PLAN.md
+
+Next: /workflow:execute or /workflow:tdd-verify
+```
+
+## TodoWrite Pattern
+
+```javascript
+// Initialize
+[
+  {content: "Execute session discovery", status: "in_progress", activeForm: "..."},
+  {content: "Execute context gathering", status: "pending", activeForm: "..."},
+  {content: "Execute TDD analysis", status: "pending", activeForm: "..."},
+  {content: "Execute TDD task generation", status: "pending", activeForm: "..."},
+  {content: "Validate TDD structure", status: "pending", activeForm: "..."}
+]
+
+// Update after each phase: mark current "completed", next "in_progress"
+```
+
+## Input Processing
+
+Convert user input to TDD-structured format:
+
+**Simple text** → Add TDD context
+**Detailed text** → Extract components with TEST_FOCUS
+**File/Issue** → Read and structure with TDD
+
+## Error Handling
+
+- **Parsing failure**: Retry once, then report
+- **Validation failure**: Report missing/invalid data
+- **Command failure**: Keep phase in_progress, report error
+- **TDD validation failure**: Report incomplete chains or wrong dependencies
+
+## Related Commands
+- `/workflow:plan` - Standard (non-TDD) planning
+- `/workflow:execute` - Execute TDD tasks
+- `/workflow:tdd-verify` - Verify TDD compliance
+- `/workflow:status` - View progress

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

@@ -0,0 +1,361 @@
+---
+name: tdd-verify
+description: Verify TDD workflow compliance and generate quality report
+usage: /workflow:tdd-verify [session-id]
+argument-hint: "[WFS-session-id]"
+examples:
+  - /workflow:tdd-verify
+  - /workflow:tdd-verify WFS-auth
+allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(gemini-wrapper:*)
+---
+
+# TDD Verification Command (/workflow:tdd-verify)
+
+## Coordinator Role
+
+**This command is a pure orchestrator**: Execute 4 phases to verify TDD workflow compliance, test coverage, and Red-Green-Refactor cycle execution.
+
+## Core Responsibilities
+- Verify TDD task chain structure
+- Analyze test coverage
+- Validate TDD cycle execution
+- Generate compliance report
+
+## 4-Phase Execution
+
+### Phase 1: Session Discovery
+**Auto-detect or use provided session**
+
+```bash
+# If session-id provided
+sessionId = argument
+
+# Else auto-detect active session
+find .workflow/ -name '.active-*' | head -1 | sed 's/.*active-//'
+```
+
+**Extract**: sessionId
+
+**Validation**: Session directory exists
+
+**TodoWrite**: Mark phase 1 completed, phase 2 in_progress
+
+---
+
+### Phase 2: Task Chain Validation
+**Validate TDD structure using bash commands**
+
+```bash
+# Load all task JSONs
+find .workflow/{sessionId}/.task/ -name '*.json'
+
+# Extract task IDs
+find .workflow/{sessionId}/.task/ -name '*.json' -exec jq -r '.id' {} \;
+
+# Check dependencies
+find .workflow/{sessionId}/.task/ -name 'IMPL-*.json' -exec jq -r '.context.depends_on[]?' {} \;
+find .workflow/{sessionId}/.task/ -name 'REFACTOR-*.json' -exec jq -r '.context.depends_on[]?' {} \;
+
+# Check meta fields
+find .workflow/{sessionId}/.task/ -name '*.json' -exec jq -r '.meta.tdd_phase' {} \;
+find .workflow/{sessionId}/.task/ -name '*.json' -exec jq -r '.meta.agent' {} \;
+```
+
+**Validation**:
+- For each feature N, verify TEST-N.M → IMPL-N.M → REFACTOR-N.M exists
+- IMPL-N.M.context.depends_on includes TEST-N.M
+- REFACTOR-N.M.context.depends_on includes IMPL-N.M
+- TEST tasks have tdd_phase="red" and agent="@code-review-test-agent"
+- IMPL/REFACTOR tasks have tdd_phase="green"/"refactor" and agent="@code-developer"
+
+**Extract**: Chain validation report
+
+**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
+
+---
+
+### Phase 3: Test Execution Analysis
+**Command**: `SlashCommand(command="/workflow:tools:tdd-coverage-analysis --session [sessionId]")`
+
+**Input**: sessionId from Phase 1
+
+**Parse Output**:
+- Coverage metrics (line, branch, function percentages)
+- TDD cycle verification results
+- Compliance score
+
+**Validation**:
+- `.workflow/{sessionId}/.process/test-results.json` exists
+- `.workflow/{sessionId}/.process/coverage-report.json` exists
+- `.workflow/{sessionId}/.process/tdd-cycle-report.md` exists
+
+**TodoWrite**: Mark phase 3 completed, phase 4 in_progress
+
+---
+
+### Phase 4: Compliance Report Generation
+**Gemini analysis for comprehensive TDD compliance report**
+
+```bash
+cd project-root && ~/.claude/scripts/gemini-wrapper -p "
+PURPOSE: Generate TDD compliance report
+TASK: Analyze TDD workflow execution and generate quality report
+CONTEXT: @{.workflow/{sessionId}/.task/*.json,.workflow/{sessionId}/.summaries/*,.workflow/{sessionId}/.process/tdd-cycle-report.md}
+EXPECTED:
+- TDD compliance score (0-100)
+- Chain completeness verification
+- Test coverage analysis summary
+- Quality recommendations
+- Red-Green-Refactor cycle validation
+- Best practices adherence assessment
+RULES: Focus on TDD best practices and workflow adherence. Be specific about violations and improvements.
+" > .workflow/{sessionId}/TDD_COMPLIANCE_REPORT.md
+```
+
+**Output**: TDD_COMPLIANCE_REPORT.md
+
+**TodoWrite**: Mark phase 4 completed
+
+**Return to User**:
+```
+TDD Verification Report - Session: {sessionId}
+
+## Chain Validation
+✅ Feature 1: TEST-1.1 → IMPL-1.1 → REFACTOR-1.1 (Complete)
+✅ Feature 2: TEST-2.1 → IMPL-2.1 → REFACTOR-2.1 (Complete)
+⚠️  Feature 3: TEST-3.1 → IMPL-3.1 (Missing REFACTOR phase)
+
+## Test Execution
+✅ All TEST tasks produced failing tests
+✅ All IMPL tasks made tests pass
+✅ All REFACTOR tasks maintained green tests
+
+## Coverage Metrics
+Line Coverage: {percentage}%
+Branch Coverage: {percentage}%
+Function Coverage: {percentage}%
+
+## Compliance Score: {score}/100
+
+Detailed report: .workflow/{sessionId}/TDD_COMPLIANCE_REPORT.md
+
+Recommendations:
+- Complete missing REFACTOR-3.1 task
+- Consider additional edge case tests for Feature 2
+- Improve test failure message clarity in Feature 1
+```
+
+## TodoWrite Pattern
+
+```javascript
+// Initialize (before Phase 1)
+TodoWrite({todos: [
+  {"content": "Identify target session", "status": "in_progress", "activeForm": "Identifying target session"},
+  {"content": "Validate task chain structure", "status": "pending", "activeForm": "Validating task chain structure"},
+  {"content": "Analyze test execution", "status": "pending", "activeForm": "Analyzing test execution"},
+  {"content": "Generate compliance report", "status": "pending", "activeForm": "Generating compliance report"}
+]})
+
+// After Phase 1
+TodoWrite({todos: [
+  {"content": "Identify target session", "status": "completed", "activeForm": "Identifying target session"},
+  {"content": "Validate task chain structure", "status": "in_progress", "activeForm": "Validating task chain structure"},
+  {"content": "Analyze test execution", "status": "pending", "activeForm": "Analyzing test execution"},
+  {"content": "Generate compliance report", "status": "pending", "activeForm": "Generating compliance report"}
+]})
+
+// Continue pattern for Phase 2, 3, 4...
+```
+
+## Validation Logic
+
+### Chain Validation Algorithm
+```
+1. Load all task JSONs from .workflow/{sessionId}/.task/
+2. Extract task IDs and group by feature number
+3. For each feature:
+   - Check TEST-N.M exists
+   - Check IMPL-N.M exists
+   - Check REFACTOR-N.M exists (optional but recommended)
+   - Verify IMPL-N.M depends_on TEST-N.M
+   - Verify REFACTOR-N.M depends_on IMPL-N.M
+   - Verify meta.tdd_phase values
+   - Verify meta.agent assignments
+4. Calculate chain completeness score
+5. Report incomplete or invalid chains
+```
+
+### Compliance Scoring
+```
+Base Score: 100 points
+
+Deductions:
+- Missing TEST task: -30 points per feature
+- Missing IMPL task: -30 points per feature
+- Missing REFACTOR task: -10 points per feature
+- Wrong dependency: -15 points per error
+- Wrong agent: -5 points per error
+- Wrong tdd_phase: -5 points per error
+- Test didn't fail initially: -10 points per feature
+- Tests didn't pass after IMPL: -20 points per feature
+- Tests broke during REFACTOR: -15 points per feature
+
+Final Score: Max(0, Base Score - Deductions)
+```
+
+## Output Files
+```
+.workflow/{session-id}/
+├── TDD_COMPLIANCE_REPORT.md     # Comprehensive compliance report ⭐
+└── .process/
+    ├── test-results.json         # From tdd-coverage-analysis
+    ├── coverage-report.json      # From tdd-coverage-analysis
+    └── tdd-cycle-report.md       # From tdd-coverage-analysis
+```
+
+## Error Handling
+
+### Session Discovery Errors
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| No active session | No .active-* file | Provide session-id explicitly |
+| Multiple active sessions | Multiple .active-* files | Provide session-id explicitly |
+| Session not found | Invalid session-id | Check available sessions |
+
+### Validation Errors
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| Task files missing | Incomplete planning | Run tdd-plan first |
+| Invalid JSON | Corrupted task files | Regenerate tasks |
+| Missing summaries | Tasks not executed | Execute tasks before verify |
+
+### Analysis Errors
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| Coverage tool missing | No test framework | Configure testing first |
+| Tests fail to run | Code errors | Fix errors before verify |
+| Gemini analysis fails | Token limit / API error | Retry or reduce context |
+
+## Integration & Usage
+
+### Command Chain
+- **Called After**: `/workflow:execute` (when TDD tasks completed)
+- **Calls**: `/workflow:tools:tdd-coverage-analysis`, Gemini wrapper
+- **Related**: `/workflow:tdd-plan`, `/workflow:status`
+
+### Basic Usage
+```bash
+# Auto-detect active session
+/workflow:tdd-verify
+
+# Specify session
+/workflow:tdd-verify WFS-auth
+```
+
+### When to Use
+- After completing all TDD tasks in a workflow
+- Before merging TDD workflow branch
+- For TDD process quality assessment
+- To identify missing TDD steps
+
+## TDD Compliance Report Structure
+
+```markdown
+# TDD Compliance Report - {Session ID}
+
+**Generated**: {timestamp}
+**Session**: {sessionId}
+**Workflow Type**: TDD
+
+## Executive Summary
+Overall Compliance Score: {score}/100
+Status: {EXCELLENT | GOOD | NEEDS IMPROVEMENT | FAILED}
+
+## Chain Analysis
+
+### Feature 1: {Feature Name}
+**Status**: ✅ Complete
+**Chain**: TEST-1.1 → IMPL-1.1 → REFACTOR-1.1
+
+- ✅ **Red Phase**: Test created and failed with clear message
+- ✅ **Green Phase**: Minimal implementation made test pass
+- ✅ **Refactor Phase**: Code improved, tests remained green
+
+### Feature 2: {Feature Name}
+**Status**: ⚠️ Incomplete
+**Chain**: TEST-2.1 → IMPL-2.1 (Missing REFACTOR-2.1)
+
+- ✅ **Red Phase**: Test created and failed
+- ⚠️ **Green Phase**: Implementation seems over-engineered
+- ❌ **Refactor Phase**: Missing
+
+**Issues**:
+- REFACTOR-2.1 task not completed
+- IMPL-2.1 implementation exceeded minimal scope
+
+[Repeat for all features]
+
+## Test Coverage Analysis
+
+### Coverage Metrics
+- Line Coverage: {percentage}% {status}
+- Branch Coverage: {percentage}% {status}
+- Function Coverage: {percentage}% {status}
+
+### Coverage Gaps
+- {file}:{lines} - Uncovered error handling
+- {file}:{lines} - Uncovered edge case
+
+## TDD Cycle Validation
+
+### Red Phase (Write Failing Test)
+- ✅ {N}/{total} features had failing tests initially
+- ⚠️ Feature 3: No evidence of initial test failure
+
+### Green Phase (Make Test Pass)
+- ✅ {N}/{total} implementations made tests pass
+- ✅ All implementations minimal and focused
+
+### Refactor Phase (Improve Quality)
+- ⚠️ {N}/{total} features completed refactoring
+- ❌ Feature 2, 4: Refactoring step skipped
+
+## Best Practices Assessment
+
+### Strengths
+- Clear test descriptions
+- Good test coverage
+- Consistent naming conventions
+- Well-structured code
+
+### Areas for Improvement
+- Some implementations over-engineered in Green phase
+- Missing refactoring steps
+- Test failure messages could be more descriptive
+
+## Recommendations
+
+### High Priority
+1. Complete missing REFACTOR tasks (Features 2, 4)
+2. Verify initial test failures for Feature 3
+3. Simplify over-engineered implementations
+
+### Medium Priority
+1. Add edge case tests for Features 1, 3
+2. Improve test failure message clarity
+3. Increase branch coverage to >85%
+
+### Low Priority
+1. Add more descriptive test names
+2. Consider parameterized tests for similar scenarios
+3. Document TDD process learnings
+
+## Conclusion
+{Summary of compliance status and next steps}
+```
+
+## Related Commands
+- `/workflow:tdd-plan` - Creates TDD workflow
+- `/workflow:execute` - Executes TDD tasks
+- `/workflow:tools:tdd-coverage-analysis` - Analyzes test coverage
+- `/workflow:status` - Views workflow progress

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

@@ -1,145 +1,487 @@
 ---
 name: test-gen
-description: Generate comprehensive test workflow based on completed implementation tasks
-usage: /workflow:test-gen [session-id]
-argument-hint: "WFS-session-id"
+description: Create independent test-fix workflow session by analyzing completed implementation
+usage: /workflow:test-gen <source-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(*)
 ---
 
-# Workflow Test Generation Command
+# Workflow Test Generation Command (/workflow:test-gen)
 
-## Overview
-Analyzes completed implementation sessions and generates comprehensive test requirements, then calls workflow:plan to create test workflow.
+## Coordinator Role
 
-## Usage
-```bash
-/workflow:test-gen                # Auto-detect active session
-/workflow:test-gen WFS-session-id # Analyze specific session
+**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 → Create test session → Parse session ID
+2. Gather cross-session context (automatic) → Parse context path
+3. Analyze implementation with concept-enhanced → Parse ANALYSIS_RESULTS.md
+4. Generate test task from analysis → Return summary
+
+## Core Rules
+
+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 (execution triggered separately)
+6. **Track Progress**: Update TodoWrite after every phase completion
+7. **Automatic Detection**: context-gather auto-detects test session and gathers source session context
+
+## 4-Phase Execution
+
+### Phase 1: Create Test Session
+**Command**: `SlashCommand(command="/workflow:session:start --new \"Test validation for [sourceSessionId]\"")`
+
+**Input**: `sourceSessionId` from user argument (e.g., `WFS-user-auth`)
+
+**Expected Behavior**:
+- Creates new session with pattern `WFS-test-[source-slug]` (e.g., `WFS-test-user-auth`)
+- Writes metadata to `workflow-session.json`:
+  - `workflow_type: "test_session"`
+  - `source_session_id: "[sourceSessionId]"`
+- Returns new session ID for subsequent phases
+
+**Parse Output**:
+- Extract: new test session ID (store as `testSessionId`)
+- Pattern: `WFS-test-[slug]`
+
+**Validation**:
+- Source session `.workflow/[sourceSessionId]/` exists
+- Source session has completed IMPL tasks (`.summaries/IMPL-*-summary.md`)
+- New test session directory created
+- Metadata includes `workflow_type` and `source_session_id`
+
+**TodoWrite**: Mark phase 1 completed, phase 2 in_progress
+
+---
+
+### Phase 2: Gather Cross-Session Context
+**Command**: `SlashCommand(command="/workflow:tools:context-gather --session [testSessionId]")`
+
+**Input**: `testSessionId` from Phase 1 (e.g., `WFS-test-user-auth`)
+
+**Automatic Detection**:
+- context-gather reads `.workflow/[testSessionId]/workflow-session.json`
+- Detects `workflow_type: "test_session"`
+- Automatically uses `source_session_id` to gather source session context
+- 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**:
+- Extract: context package path (store as `contextPath`)
+- Pattern: `.workflow/[testSessionId]/.process/context-package.json`
+
+**Validation**:
+- Context package created in test session directory
+- Contains source session artifacts (summaries, changed files)
+- Includes test file inventory
+
+**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
+
+---
+
+### Phase 3: Implementation Analysis
+**Command**: `SlashCommand(command="/workflow:tools:concept-enhanced --session [testSessionId] --context [contextPath]")`
+
+**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**:
+- Reads context-package.json with cross-session artifacts
+- Executes parallel analysis (Gemini for test strategy, optional Codex for validation)
+- Generates comprehensive test execution strategy
+- Identifies code modification targets for test fixes
+- Provides feasibility assessment for test validation
+
+**Parse Output**:
+- Verify `.workflow/[testSessionId]/.process/ANALYSIS_RESULTS.md` created
+- Contains test strategy and execution plan
+- Lists code modification targets (format: `file:function:lines` or `file`)
+- Includes risk assessment and optimization recommendations
+
+**Validation**:
+- File `.workflow/[testSessionId]/.process/ANALYSIS_RESULTS.md` exists
+- Contains complete analysis sections:
+  - 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: Generate Test Task
+**Command**: `SlashCommand(command="/workflow:tools:task-generate --session [testSessionId]")`
+
+**Input**: `testSessionId` from Phase 1
+
+**Expected Behavior**:
+- Reads ANALYSIS_RESULTS.md from Phase 3
+- Extracts test strategy and code modification targets
+- Generates `IMPL-001.json` (reusing standard format) with:
+  - `meta.type: "test-fix"` (enables @test-fix-agent assignment)
+  - `meta.agent: "@test-fix-agent"`
+  - `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**:
+- Task JSON has `id: "IMPL-001"` and `meta.type: "test-fix"`
+- 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**:
+```
+Independent test-fix workflow created successfully!
+
+Source Session: [sourceSessionId]
+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
 ```
 
-## Dynamic Session ID Resolution
+---
 
-The `${SESSION_ID}` variable is dynamically resolved based on:
+## TodoWrite Pattern
 
-1. **Command argument**: If session-id provided as argument, use it directly
-2. **Auto-detection**: If no argument, detect from active session markers
-3. **Format**: Always in format `WFS-session-name`
+```javascript
+// Initialize (before Phase 1)
+TodoWrite({todos: [
+  {"content": "Create independent test session", "status": "in_progress", "activeForm": "Creating test session"},
+  {"content": "Gather cross-session context", "status": "pending", "activeForm": "Gathering cross-session context"},
+  {"content": "Analyze implementation for test strategy", "status": "pending", "activeForm": "Analyzing implementation"},
+  {"content": "Generate test validation task", "status": "pending", "activeForm": "Generating test validation task"}
+]})
 
-```bash
-# Example resolution logic:
-# If argument provided: SESSION_ID = "WFS-user-auth"
-# If no argument: SESSION_ID = $(find .workflow/ -name '.active-*' | head -1 | sed 's/.*active-//')
+// After Phase 1
+TodoWrite({todos: [
+  {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
+  {"content": "Gather cross-session context", "status": "in_progress", "activeForm": "Gathering cross-session context"},
+  {"content": "Analyze implementation for test strategy", "status": "pending", "activeForm": "Analyzing implementation"},
+  {"content": "Generate test validation task", "status": "pending", "activeForm": "Generating test validation task"}
+]})
+
+// 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"}
+]})
 ```
 
-## Implementation Flow
+## Data Flow
 
-### Step 1: Identify Target Session
-```bash
-# Auto-detect active session (if no session-id provided)
-find .workflow/ -name '.active-*' | head -1 | sed 's/.*active-//'
-
-# Use provided session-id or detected session-id
-# SESSION_ID = provided argument OR detected active session
+```
+User: /workflow:test-gen WFS-user-auth
+    ↓
+Phase 1: session-start --new "Test validation for WFS-user-auth"
+    ↓ 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: context-gather --session WFS-test-user-auth
+    ↓ Auto-detects: test session type from workflow-session.json
+    ↓ 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: concept-enhanced --session WFS-test-user-auth --context context-package.json
+    ↓ Reads: context-package.json with cross-session artifacts
+    ↓ 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: task-generate --session WFS-test-user-auth
+    ↓ Reads: ANALYSIS_RESULTS.md with test strategy and code targets
+    ↓ Generates: IMPL-001.json with meta.type="test-fix"
+    ↓ Output: Task, plan, and todo files in test session
+    ↓
+Return: Summary with next steps (user triggers /workflow:execute separately)
 ```
 
-### Step 2: Get Session Start Time
-```bash
-cat .workflow/WFS-${SESSION_ID}/workflow-session.json | jq -r .created_at
+## Session Metadata Design
+
+**Test Session (`WFS-test-user-auth/workflow-session.json`)**:
+```json
+{
+  "session_id": "WFS-test-user-auth",
+  "project": "Test validation for user authentication implementation",
+  "status": "planning",
+  "created_at": "2025-10-03T12:00:00Z",
+  "workflow_type": "test_session",
+  "source_session_id": "WFS-user-auth"
+}
 ```
 
-### Step 3: Git Change Analysis (using session start time)
-```bash
-git log --since="$(cat .workflow/WFS-${SESSION_ID}/workflow-session.json | jq -r .created_at)" --name-only --pretty=format: | sort -u | grep -v '^$'
+## Automatic Cross-Session Context Collection
+
+When `context-gather` detects `workflow_type: "test_session"`:
+
+**Collected from Source Session** (`.workflow/WFS-user-auth/`):
+- Implementation summaries: `.summaries/IMPL-*-summary.md`
+- Code changes: `git log --since=[source_created_at] --name-only`
+- 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 `IMPL-001.json` (reusing standard format) with:
+
+```json
+{
+  "id": "IMPL-001",
+  "title": "Execute and validate tests for [sourceSessionId]",
+  "status": "pending",
+  "meta": {
+    "type": "test-fix",
+    "agent": "@test-fix-agent"
+  },
+  "context": {
+    "requirements": [
+      "Execute complete test suite for all implemented modules",
+      "Diagnose and fix any test failures",
+      "Ensure all tests pass before completion"
+    ],
+    "focus_paths": ["src/**/*.test.ts", "src/**/implementation.ts"],
+    "acceptance": [
+      "All tests pass successfully",
+      "No test failures or errors",
+      "Code is approved and ready for deployment"
+    ],
+    "depends_on": [],
+    "artifacts": []
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "load_source_session_summaries",
+        "action": "Load implementation summaries from source session",
+        "commands": [
+          "bash(find .workflow/[sourceSessionId]/.summaries/ -name 'IMPL-*-summary.md' 2>/dev/null)",
+          "Read(.workflow/[sourceSessionId]/.summaries/IMPL-001-summary.md)"
+        ],
+        "output_to": "implementation_context",
+        "on_error": "skip_optional"
+      },
+      {
+        "step": "analyze_test_files",
+        "action": "Identify test files and coverage",
+        "commands": [
+          "mcp__code-index__find_files(pattern=\"*.test.*\")",
+          "mcp__code-index__search_code_advanced(pattern=\"test|describe|it\", file_pattern=\"*.test.*\")"
+        ],
+        "output_to": "test_inventory",
+        "on_error": "fail"
+      }
+    ],
+    "implementation_approach": {
+      "task_description": "Execute tests and fix failures until all pass",
+      "modification_points": [
+        "Run test suite using detected framework",
+        "Parse test output to identify failures",
+        "Diagnose root cause of failures",
+        "Modify source code to fix issues",
+        "Re-run tests to verify fixes"
+      ],
+      "logic_flow": [
+        "Load implementation context",
+        "Identify test framework and configuration",
+        "Execute complete test suite",
+        "If failures: analyze error messages",
+        "Fix source code based on diagnosis",
+        "Re-run tests",
+        "Repeat until all tests pass"
+      ]
+    },
+    "target_files": ["src/**/*.test.ts", "src/**/implementation.ts"]
+  }
+}
 ```
 
-### Step 4: Filter Code Files
-```bash
-git log --since="$(cat .workflow/WFS-${SESSION_ID}/workflow-session.json | jq -r .created_at)" --name-only --pretty=format: | sort -u | grep -E '\.(js|ts|jsx|tsx|py|java|go|rs)$'
+## Error Handling
+
+### Phase 1 Failures
+- **Source session not found**: Return error "Source session [sourceSessionId] not found in .workflow/"
+- **Invalid source session**: Return error "Source session [sourceSessionId] has no completed IMPL tasks"
+- **Session creation failed**: Return error "Could not create test session. Check /workflow:session:start"
+
+### Phase 2 Failures
+- **Context gathering failed**: Return error "Could not gather cross-session context. Check source session artifacts"
+- **No source artifacts**: Return error "Source session has no implementation summaries or git history"
+
+### Phase 3 Failures
+- **Analysis failed**: Return error "Implementation analysis failed. Check context package and ANALYSIS_RESULTS.md"
+- **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
+- **Task generation failed**: Retry once, then return error with details
+- **Invalid task structure**: Return error with JSON validation details
+
+## Workflow Integration
+
+### Complete Flow Example
+```
+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 in WFS-auth
+
+2. Test Generation Phase (test-gen)
+   /workflow:test-gen WFS-auth
+   Phase 1: session-start → Creates WFS-test-auth session
+   Phase 2: context-gather → Gathers from WFS-auth, creates context-package.json
+   Phase 3: concept-enhanced → Analyzes implementation, creates ANALYSIS_RESULTS.md
+   Phase 4: task-generate → Creates IMPL-001.json with meta.type="test-fix"
+   Returns: Summary with next steps
+
+3. Test Execution Phase (user-triggered)
+   /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
+   → Re-runs tests
+   → All pass → Code approved ✅
 ```
 
-### Step 5: Load Session Context
-```bash
-cat .workflow/WFS-${SESSION_ID}/.summaries/IMPL-*-summary.md 2>/dev/null
-```
+### Output Files Created
 
-### Step 6: Extract Focus Paths
-```bash
-find .workflow/WFS-${SESSION_ID}/.task/ -name '*.json' -exec jq -r '.context.focus_paths[]?' {} \;
-```
+**In Test Session** (`.workflow/WFS-test-auth/`):
+- `workflow-session.json` - Contains workflow_type and source_session_id
+- `.process/context-package.json` - Cross-session context from WFS-auth
+- `.process/ANALYSIS_RESULTS.md` - Test strategy and code targets from concept-enhanced
+- `.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
 
-### Step 7: Gemini Analysis and Planning Document Generation
-```bash
-cd project-root && ~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: Analyze implementation and generate comprehensive test planning document
-TASK: Review changed files and implementation context to create detailed test planning document
-CONTEXT: Changed files: [changed_files], Implementation summaries: [impl_summaries], Focus paths: [focus_paths]
-EXPECTED: Complete test planning document including:
-- Test strategy analysis
-- Critical test scenarios identification
-- Edge cases and error conditions
-- Test priority matrix
-- Resource requirements
-- Implementation approach recommendations
-- Specific test cases with acceptance criteria
-RULES: Generate structured markdown document suitable for workflow planning. Focus on actionable test requirements based on actual implementation changes.
-" > .workflow/WFS-${SESSION_ID}/.process/GEMINI_TEST_PLAN.md
-```
+## Best Practices
 
-### Step 8: Generate Combined Test Requirements Document
-```bash
-mkdir -p .workflow/WFS-${SESSION_ID}/.process
-```
+1. **Run after implementation complete**: Ensure source session has completed IMPL tasks and summaries
+2. **Check git commits**: Implementation changes should be committed for accurate git log analysis
+3. **Verify test files exist**: Source implementation should include test files
+4. **Independent sessions**: Test session is separate from implementation session for clean separation
+5. **Monitor execution**: Use `/workflow:status` to track test-fix progress after /workflow:execute
 
-```bash
-cat > .workflow/WFS-${SESSION_ID}/.process/TEST_REQUIREMENTS.md << 'EOF'
-# Test Requirements Summary for WFS-${SESSION_ID}
+## Coordinator Checklist
 
-## Analysis Data Sources
-- Git change analysis results
-- Implementation summaries and context
-- Gemini-generated test planning document
+✅ Initialize TodoWrite before any command (4 phases)
+✅ Phase 1: Create test session with source session ID
+✅ Parse new test session ID from Phase 1 output
+✅ Phase 2: Run context-gather (auto-detects test session, no extra params)
+✅ Verify context-package.json contains cross-session artifacts
+✅ Phase 3: Run concept-enhanced with session and context path
+✅ Verify ANALYSIS_RESULTS.md contains test strategy and code targets
+✅ 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 after Phase 4 (execution is separate user action)
 
-## Reference Documents
-- Detailed test plan: GEMINI_TEST_PLAN.md
-- Implementation context: IMPL-*-summary.md files
+## Required Tool Modifications
 
-## Integration Note
-This document combines analysis data with Gemini-generated planning document for comprehensive test workflow generation.
-EOF
-```
+### `/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
 
-### Step 9: Call Workflow Plan with Gemini Planning Document
-```bash
-/workflow:plan .workflow/WFS-${SESSION_ID}/.process/GEMINI_TEST_PLAN.md
-```
+### `/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
 
-## Simple Bash Commands
+### `/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
 
-### Basic Operations
-- **Find active session**: `find .workflow/ -name '.active-*'`
-- **Get git changes**: `git log --since='date' --name-only`
-- **Filter code files**: `grep -E '\.(js|ts|py)$'`
-- **Load summaries**: `cat .workflow/WFS-*/summaries/*.md`
-- **Extract JSON data**: `jq -r '.context.focus_paths[]'`
-- **Create directory**: `mkdir -p .workflow/session/.process`
-- **Write file**: `cat > file << 'EOF'`
+### `/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
 
-### Gemini CLI Integration
-- **Planning command**: `~/.claude/scripts/gemini-wrapper -p "prompt" > GEMINI_TEST_PLAN.md`
-- **Context loading**: Include changed files and implementation context
-- **Document generation**: Creates comprehensive test planning document
-- **Direct handoff**: Pass Gemini planning document to workflow:plan
-
-## No Complex Logic
-- No variables or functions
-- No conditional statements
-- No loops or complex pipes
-- Direct bash commands only
-- Gemini CLI for intelligent analysis
+### `/workflow:execute`
+- No changes required (already dispatches by meta.agent)
 
 ## Related Commands
-- `/workflow:plan` - Called to generate test workflow
-- `/workflow:execute` - Executes generated test tasks
-- `/workflow:status` - Shows test workflow progress
+- `/workflow:plan` - Create implementation workflow (run before test-gen)
+- `/workflow:session:start` - Phase 1 tool for test session creation
+- `/workflow:tools:context-gather` - Phase 2 tool for cross-session context collection
+- `/workflow:tools:concept-enhanced` - Phase 3 tool for implementation analysis and test strategy
+- `/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

@@ -158,7 +158,7 @@ Task(
   "status": "pending",
   "meta": {
     "type": "feature|bugfix|refactor|test|docs",
-    "agent": "@code-developer|@code-review-test-agent"
+    "agent": "@code-developer|@test-fix-agent|@general-purpose"
   },
   "context": {
     "requirements": ["extracted from analysis"],
@@ -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-tdd.md

@@ -0,0 +1,368 @@
+---
+name: task-generate-tdd
+description: Generate TDD task chains with Red-Green-Refactor dependencies
+usage: /workflow:tools:task-generate-tdd --session <session_id> [--agent]
+argument-hint: "--session WFS-session-id [--agent]"
+examples:
+  - /workflow:tools:task-generate-tdd --session WFS-auth
+  - /workflow:tools:task-generate-tdd --session WFS-auth --agent
+allowed-tools: Read(*), Write(*), Bash(gemini-wrapper:*), TodoWrite(*)
+---
+
+# TDD Task Generation Command
+
+## Overview
+Generate TDD-specific task chains from analysis results with enforced Red-Green-Refactor structure and dependencies.
+
+## Core Philosophy
+- **TDD-First**: Every feature starts with a failing test
+- **Chain-Enforced**: Dependencies ensure proper TDD cycle
+- **Phase-Explicit**: Each task marked with Red/Green/Refactor phase
+- **Artifact-Aware**: Integrates brainstorming outputs
+- **Memory-First**: Reuse loaded documents from memory
+
+## Core Responsibilities
+- Parse analysis results and identify testable features
+- Generate Red-Green-Refactor task chains for each feature
+- Enforce proper dependencies (TEST → IMPL → REFACTOR)
+- Create TDD_PLAN.md and enhanced IMPL_PLAN.md
+- Generate TODO_LIST.md with TDD phase indicators
+- Update session state for TDD execution
+
+## Execution Lifecycle
+
+### Phase 1: Input Validation & Discovery
+**⚡ Memory-First Rule**: Skip file loading if documents already in conversation memory
+
+1. **Session Validation**
+   - If session metadata in memory → Skip loading
+   - Else: Load `.workflow/{session_id}/workflow-session.json`
+
+2. **Analysis Results Loading**
+   - If ANALYSIS_RESULTS.md in memory → Skip loading
+   - Else: Read `.workflow/{session_id}/.process/ANALYSIS_RESULTS.md`
+
+3. **Artifact Discovery**
+   - If artifact inventory in memory → Skip scanning
+   - Else: Scan `.workflow/{session_id}/.brainstorming/` directory
+   - Detect: synthesis-specification.md, topic-framework.md, role analyses
+
+### Phase 2: TDD Task Analysis
+
+#### Gemini TDD Breakdown
+```bash
+cd project-root && ~/.claude/scripts/gemini-wrapper -p "
+PURPOSE: Generate TDD task breakdown with Red-Green-Refactor chains
+TASK: Analyze ANALYSIS_RESULTS.md and create TDD-structured task breakdown
+CONTEXT: @{.workflow/{session_id}/ANALYSIS_RESULTS.md,.workflow/{session_id}/.brainstorming/*}
+EXPECTED:
+- Feature list with testable requirements (identify 3-8 features)
+- Test cases for each feature (Red phase) - specific test scenarios
+- Implementation requirements (Green phase) - minimal code to pass
+- Refactoring opportunities (Refactor phase) - quality improvements
+- Task dependencies and execution order
+- Focus paths for each phase
+RULES:
+- Each feature must have TEST → IMPL → REFACTOR chain
+- Tests must define clear failure conditions
+- Implementation must be minimal to pass tests
+- Refactoring must maintain green tests
+- Output structured markdown for task generation
+- Maximum 10 features (30 total tasks)
+" > .workflow/{session_id}/.process/TDD_TASK_BREAKDOWN.md
+```
+
+### Phase 3: TDD Task JSON Generation
+
+#### Task Chain Structure
+For each feature, generate 3 tasks with ID format:
+- **TEST-N.M** (Red phase)
+- **IMPL-N.M** (Green phase)
+- **REFACTOR-N.M** (Refactor phase)
+
+#### Chain Dependency Rules
+- **IMPL depends_on TEST**: Cannot implement before test exists
+- **REFACTOR depends_on IMPL**: Cannot refactor before implementation
+- **Cross-feature dependencies**: If Feature 2 needs Feature 1, then `IMPL-2.1 depends_on ["REFACTOR-1.1"]`
+
+#### Agent Assignment
+- **TEST tasks** → `@code-review-test-agent`
+- **IMPL tasks** → `@code-developer`
+- **REFACTOR tasks** → `@code-developer`
+
+#### Meta Fields
+- `meta.type`: "test" | "feature" | "refactor"
+- `meta.agent`: Agent for task execution
+- `meta.tdd_phase`: "red" | "green" | "refactor"
+
+#### Task JSON Examples
+
+**RED Phase - Test Task (TEST-1.1.json)**
+```json
+{
+  "id": "TEST-1.1",
+  "title": "Write failing test for user authentication",
+  "status": "pending",
+  "meta": {
+    "type": "test",
+    "agent": "@code-review-test-agent",
+    "tdd_phase": "red"
+  },
+  "context": {
+    "requirements": [
+      "Write test case for login with valid credentials",
+      "Test should fail with 'AuthService not implemented' error",
+      "Include tests for invalid credentials and edge cases"
+    ],
+    "focus_paths": ["tests/auth/login.test.ts"],
+    "acceptance": [
+      "Test file created with at least 3 test cases",
+      "Test runs and fails with clear error message",
+      "Test assertions define expected behavior"
+    ],
+    "depends_on": []
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "check_test_framework",
+        "action": "Verify test framework is configured",
+        "command": "bash(npm list jest || npm list vitest)",
+        "output_to": "test_framework_info",
+        "on_error": "warn"
+      }
+    ]
+  }
+}
+```
+
+**GREEN Phase - Implementation Task (IMPL-1.1.json)**
+```json
+{
+  "id": "IMPL-1.1",
+  "title": "Implement user authentication to pass tests",
+  "status": "pending",
+  "meta": {
+    "type": "feature",
+    "agent": "@code-developer",
+    "tdd_phase": "green"
+  },
+  "context": {
+    "requirements": [
+      "Implement minimal AuthService to pass TEST-1.1",
+      "Handle valid and invalid credentials",
+      "Return appropriate success/error responses"
+    ],
+    "focus_paths": ["src/auth/AuthService.ts", "tests/auth/login.test.ts"],
+    "acceptance": [
+      "All tests in TEST-1.1 pass",
+      "Implementation is minimal and focused",
+      "No over-engineering or premature optimization"
+    ],
+    "depends_on": ["TEST-1.1"]
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "load_test_requirements",
+        "action": "Read test specifications from TEST phase",
+        "command": "bash(cat .workflow/WFS-xxx/.summaries/TEST-1.1-summary.md)",
+        "output_to": "test_requirements",
+        "on_error": "fail"
+      },
+      {
+        "step": "verify_tests_failing",
+        "action": "Confirm tests are currently failing",
+        "command": "bash(npm test -- tests/auth/login.test.ts || echo 'Tests failing as expected')",
+        "output_to": "initial_test_status",
+        "on_error": "warn"
+      }
+    ],
+    "post_completion": [
+      {
+        "step": "verify_tests_passing",
+        "action": "Confirm all tests now pass",
+        "command": "bash(npm test -- tests/auth/login.test.ts)",
+        "output_to": "final_test_status",
+        "on_error": "fail"
+      }
+    ]
+  }
+}
+```
+
+**REFACTOR Phase - Refactoring Task (REFACTOR-1.1.json)**
+```json
+{
+  "id": "REFACTOR-1.1",
+  "title": "Refactor authentication implementation",
+  "status": "pending",
+  "meta": {
+    "type": "refactor",
+    "agent": "@code-developer",
+    "tdd_phase": "refactor"
+  },
+  "context": {
+    "requirements": [
+      "Improve code quality while keeping tests green",
+      "Remove duplication in credential validation",
+      "Improve error handling and logging",
+      "Enhance code readability and maintainability"
+    ],
+    "focus_paths": ["src/auth/AuthService.ts", "tests/auth/login.test.ts"],
+    "acceptance": [
+      "Code quality improved (complexity, readability)",
+      "All tests still pass after refactoring",
+      "No new functionality added",
+      "Duplication eliminated"
+    ],
+    "depends_on": ["IMPL-1.1"]
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "verify_tests_passing",
+        "action": "Run tests to confirm green state before refactoring",
+        "command": "bash(npm test -- tests/auth/login.test.ts)",
+        "output_to": "test_status",
+        "on_error": "fail"
+      },
+      {
+        "step": "analyze_code_quality",
+        "action": "Run linter and complexity analysis",
+        "command": "bash(npm run lint src/auth/AuthService.ts)",
+        "output_to": "quality_metrics",
+        "on_error": "warn"
+      }
+    ],
+    "post_completion": [
+      {
+        "step": "verify_tests_still_passing",
+        "action": "Confirm tests remain green after refactoring",
+        "command": "bash(npm test -- tests/auth/login.test.ts)",
+        "output_to": "final_test_status",
+        "on_error": "fail"
+      }
+    ]
+  }
+}
+```
+
+### Phase 4: TDD_PLAN.md Generation
+
+Generate TDD-specific plan with:
+- Feature breakdown
+- Red-Green-Refactor chains
+- Execution order
+- TDD compliance checkpoints
+
+### Phase 5: Enhanced IMPL_PLAN.md Generation
+
+Generate standard IMPL_PLAN.md with TDD context reference.
+
+### Phase 6: TODO_LIST.md Generation
+
+Generate task list with TDD phase indicators:
+```markdown
+## Feature 1: {Feature Name}
+- [ ] **TEST-1.1**: Write failing test (🔴 RED) → [📋](./.task/TEST-1.1.json)
+- [ ] **IMPL-1.1**: Implement to pass tests (🟢 GREEN) [depends: TEST-1.1] → [📋](./.task/IMPL-1.1.json)
+- [ ] **REFACTOR-1.1**: Refactor implementation (🔵 REFACTOR) [depends: IMPL-1.1] → [📋](./.task/REFACTOR-1.1.json)
+```
+
+### Phase 7: Session State Update
+
+Update workflow-session.json with TDD metadata:
+```json
+{
+  "workflow_type": "tdd",
+  "feature_count": 10,
+  "task_count": 30,
+  "tdd_chains": 10
+}
+```
+
+## Output Files Structure
+```
+.workflow/{session-id}/
+├── IMPL_PLAN.md                     # Standard implementation plan
+├── TDD_PLAN.md                      # TDD-specific plan ⭐ NEW
+├── TODO_LIST.md                     # Progress tracking with TDD phases
+├── .task/
+│   ├── TEST-1.1.json                # Red phase task
+│   ├── IMPL-1.1.json                # Green phase task
+│   ├── REFACTOR-1.1.json            # Refactor phase task
+│   └── ...
+└── .process/
+    ├── ANALYSIS_RESULTS.md          # Input from concept-enhanced
+    ├── TDD_TASK_BREAKDOWN.md        # Gemini TDD breakdown ⭐ NEW
+    └── context-package.json         # Input from context-gather
+```
+
+## Validation Rules
+
+### Chain Completeness
+- Every TEST-N.M must have corresponding IMPL-N.M and REFACTOR-N.M
+
+### Dependency Enforcement
+- IMPL-N.M must have `depends_on: ["TEST-N.M"]`
+- REFACTOR-N.M must have `depends_on: ["IMPL-N.M"]`
+
+### Task Limits
+- Maximum 10 features (30 tasks total)
+- Flat hierarchy only
+
+## Error Handling
+
+### Input Validation Errors
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| Session not found | Invalid session ID | Verify session exists |
+| Analysis missing | Incomplete planning | Run concept-enhanced first |
+
+### TDD Generation Errors
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| Feature count exceeds 10 | Too many features | Re-scope requirements |
+| Missing test framework | No test config | Configure testing first |
+| Invalid chain structure | Parsing error | Fix TDD breakdown |
+
+## Integration & Usage
+
+### Command Chain
+- **Called By**: `/workflow:tdd-plan` (Phase 4)
+- **Calls**: Gemini wrapper for TDD breakdown
+- **Followed By**: `/workflow:execute`, `/workflow:tdd-verify`
+
+### Basic Usage
+```bash
+# Manual mode (default)
+/workflow:tools:task-generate-tdd --session WFS-auth
+
+# Agent mode (autonomous task generation)
+/workflow:tools:task-generate-tdd --session WFS-auth --agent
+```
+
+### Expected Output
+```
+TDD task generation complete for session: WFS-auth
+
+Features analyzed: 5
+TDD chains generated: 5
+Total tasks: 15 (5 TEST + 5 IMPL + 5 REFACTOR)
+
+Structure:
+- Feature 1: TEST-1.1 → IMPL-1.1 → REFACTOR-1.1
+- Feature 2: TEST-2.1 → IMPL-2.1 → REFACTOR-2.1
+
+Plans generated:
+- TDD Plan: .workflow/WFS-auth/TDD_PLAN.md
+- Implementation Plan: .workflow/WFS-auth/IMPL_PLAN.md
+
+Next: /workflow:execute or /workflow:tdd-verify
+```
+
+## Related Commands
+- `/workflow:tdd-plan` - Orchestrates TDD workflow planning
+- `/workflow:execute` - Executes TDD tasks in order
+- `/workflow:tdd-verify` - Verifies TDD compliance

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

@@ -67,8 +67,8 @@ Generate task JSON files and IMPL_PLAN.md from analysis results with automatic a
   "title": "Descriptive task name",
   "status": "pending|active|completed|blocked|container",
   "meta": {
-    "type": "feature|bugfix|refactor|test|docs",
-    "agent": "@code-developer|@planning-agent|@code-review-test-agent"
+    "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
+    "agent": "@code-developer|@test-fix-agent|@general-purpose"
   },
   "context": {
     "requirements": ["Clear requirement from analysis"],
@@ -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
-5. Create individual task JSON files in `.task/`
+4. **Determine modification targets**: Extract specific code locations from analysis
+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
 
@@ -188,9 +220,12 @@ Generate task JSON files and IMPL_PLAN.md from analysis results with automatic a
 #### Artifact-Task Mapping
 - **synthesis-specification.md** → All tasks
 - **ui-designer/analysis.md** → UI/Frontend tasks
+- **ux-expert/analysis.md** → UX/Interaction tasks
 - **system-architect/analysis.md** → Architecture/Backend tasks
-- **security-expert/analysis.md** → Security tasks
+- **subject-matter-expert/analysis.md** → Domain/Standards tasks
 - **data-architect/analysis.md** → Data/API tasks
+- **scrum-master/analysis.md** → Sprint/Process tasks
+- **product-owner/analysis.md** → Backlog/Story tasks
 
 ### Phase 4: IMPL_PLAN.md Generation
 

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

@@ -0,0 +1,284 @@
+---
+name: tdd-coverage-analysis
+description: Analyze test coverage and TDD cycle execution
+usage: /workflow:tools:tdd-coverage-analysis --session <session_id>
+argument-hint: "--session WFS-session-id"
+examples:
+  - /workflow:tools:tdd-coverage-analysis --session WFS-auth
+allowed-tools: Read(*), Write(*), Bash(*)
+---
+
+# TDD Coverage Analysis Command
+
+## Overview
+Analyze test coverage and verify Red-Green-Refactor cycle execution for TDD workflow validation.
+
+## Core Responsibilities
+- Extract test files from TEST tasks
+- Run test suite with coverage
+- Parse coverage metrics
+- Verify TDD cycle execution (Red -> Green -> Refactor)
+- Generate coverage and cycle reports
+
+## Execution Lifecycle
+
+### Phase 1: Extract Test Tasks
+```bash
+find .workflow/{session_id}/.task/ -name 'TEST-*.json' -exec jq -r '.context.focus_paths[]' {} \;
+```
+
+**Output**: List of test directories/files from all TEST tasks
+
+### Phase 2: Run Test Suite
+```bash
+# Node.js/JavaScript
+npm test -- --coverage --json > .workflow/{session_id}/.process/test-results.json
+
+# Python
+pytest --cov --json-report > .workflow/{session_id}/.process/test-results.json
+
+# Other frameworks (detect from project)
+[test_command] --coverage --json-output .workflow/{session_id}/.process/test-results.json
+```
+
+**Output**: test-results.json with coverage data
+
+### Phase 3: Parse Coverage Data
+```bash
+jq '.coverage' .workflow/{session_id}/.process/test-results.json > .workflow/{session_id}/.process/coverage-report.json
+```
+
+**Extract**:
+- Line coverage percentage
+- Branch coverage percentage
+- Function coverage percentage
+- Uncovered lines/branches
+
+### Phase 4: Verify TDD Cycle
+
+For each TDD chain (TEST-N.M -> IMPL-N.M -> REFACTOR-N.M):
+
+**1. Red Phase Verification**
+```bash
+# Check TEST task summary
+cat .workflow/{session_id}/.summaries/TEST-N.M-summary.md
+```
+
+Verify:
+- Tests were created
+- Tests failed initially
+- Failure messages were clear
+
+**2. Green Phase Verification**
+```bash
+# Check IMPL task summary
+cat .workflow/{session_id}/.summaries/IMPL-N.M-summary.md
+```
+
+Verify:
+- Implementation was completed
+- Tests now pass
+- Implementation was minimal
+
+**3. Refactor Phase Verification**
+```bash
+# Check REFACTOR task summary
+cat .workflow/{session_id}/.summaries/REFACTOR-N.M-summary.md
+```
+
+Verify:
+- Refactoring was completed
+- Tests still pass
+- Code quality improved
+
+### Phase 5: Generate Analysis Report
+
+Create `.workflow/{session_id}/.process/tdd-cycle-report.md`:
+
+```markdown
+# TDD Cycle Analysis - {Session ID}
+
+## Coverage Metrics
+- **Line Coverage**: {percentage}%
+- **Branch Coverage**: {percentage}%
+- **Function Coverage**: {percentage}%
+
+## Coverage Details
+### Covered
+- {covered_lines} lines
+- {covered_branches} branches
+- {covered_functions} functions
+
+### Uncovered
+- Lines: {uncovered_line_numbers}
+- Branches: {uncovered_branch_locations}
+
+## TDD Cycle Verification
+
+### Feature 1: {Feature Name}
+**Chain**: TEST-1.1 -> IMPL-1.1 -> REFACTOR-1.1
+
+- [PASS] **Red Phase**: Tests created and failed initially
+- [PASS] **Green Phase**: Implementation made tests pass
+- [PASS] **Refactor Phase**: Refactoring maintained green tests
+
+### Feature 2: {Feature Name}
+**Chain**: TEST-2.1 -> IMPL-2.1 -> REFACTOR-2.1
+
+- [PASS] **Red Phase**: Tests created and failed initially
+- [WARN] **Green Phase**: Tests pass but implementation seems over-engineered
+- [PASS] **Refactor Phase**: Refactoring maintained green tests
+
+[Repeat for all features]
+
+## TDD Compliance Summary
+- **Total Chains**: {N}
+- **Complete Cycles**: {N}
+- **Incomplete Cycles**: {0}
+- **Compliance Score**: {score}/100
+
+## Gaps Identified
+- Feature 3: Missing initial test failure verification
+- Feature 5: No refactoring step completed
+
+## Recommendations
+- Complete missing refactoring steps
+- Add edge case tests for Feature 2
+- Verify test failure messages are descriptive
+```
+
+## Output Files
+```
+.workflow/{session-id}/
+└── .process/
+    ├── test-results.json         # Raw test execution results
+    ├── coverage-report.json      # Parsed coverage data
+    └── tdd-cycle-report.md       # TDD cycle analysis
+```
+
+## Test Framework Detection
+
+Auto-detect test framework from project:
+
+```bash
+# Check for test frameworks
+if [ -f "package.json" ] && grep -q "jest\|mocha\|vitest" package.json; then
+    TEST_CMD="npm test -- --coverage --json"
+elif [ -f "pytest.ini" ] || [ -f "setup.py" ]; then
+    TEST_CMD="pytest --cov --json-report"
+elif [ -f "Cargo.toml" ]; then
+    TEST_CMD="cargo test -- --test-threads=1 --nocapture"
+elif [ -f "go.mod" ]; then
+    TEST_CMD="go test -coverprofile=coverage.out -json ./..."
+else
+    TEST_CMD="echo 'No supported test framework found'"
+fi
+```
+
+## TDD Cycle Verification Algorithm
+
+```
+For each feature N:
+  1. Load TEST-N.M-summary.md
+     IF summary missing:
+       Mark: "Red phase incomplete"
+       SKIP to next feature
+
+     CHECK: Contains "test" AND "fail"
+     IF NOT found:
+       Mark: "Red phase verification failed"
+     ELSE:
+       Mark: "Red phase [PASS]"
+
+  2. Load IMPL-N.M-summary.md
+     IF summary missing:
+       Mark: "Green phase incomplete"
+       SKIP to next feature
+
+     CHECK: Contains "pass" OR "green"
+     IF NOT found:
+       Mark: "Green phase verification failed"
+     ELSE:
+       Mark: "Green phase [PASS]"
+
+  3. Load REFACTOR-N.M-summary.md
+     IF summary missing:
+       Mark: "Refactor phase incomplete"
+       CONTINUE (refactor is optional)
+
+     CHECK: Contains "refactor" AND "pass"
+     IF NOT found:
+       Mark: "Refactor phase verification failed"
+     ELSE:
+       Mark: "Refactor phase [PASS]"
+
+  4. Calculate chain score:
+     - Red + Green + Refactor all [PASS] = 100%
+     - Red + Green [PASS], Refactor missing = 80%
+     - Red [PASS], Green missing = 40%
+     - All missing = 0%
+```
+
+## Coverage Metrics Calculation
+
+```bash
+# Parse coverage from test-results.json
+line_coverage=$(jq '.coverage.lineCoverage' test-results.json)
+branch_coverage=$(jq '.coverage.branchCoverage' test-results.json)
+function_coverage=$(jq '.coverage.functionCoverage' test-results.json)
+
+# Calculate overall score
+overall_score=$(echo "($line_coverage + $branch_coverage + $function_coverage) / 3" | bc)
+```
+
+## Error Handling
+
+### Test Execution Errors
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| Test framework not found | No test config | Configure test framework first |
+| Tests fail to run | Syntax errors | Fix code before analysis |
+| Coverage not available | Missing coverage tool | Install coverage plugin |
+
+### Cycle Verification Errors
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| Summary missing | Task not executed | Execute tasks before analysis |
+| Invalid summary format | Corrupted file | Re-run task to regenerate |
+| No test evidence | Tests not committed | Ensure tests are committed |
+
+## Integration & Usage
+
+### Command Chain
+- **Called By**: `/workflow:tdd-verify` (Phase 3)
+- **Calls**: Test framework commands (npm test, pytest, etc.)
+- **Followed By**: Compliance report generation
+
+### Basic Usage
+```bash
+/workflow:tools:tdd-coverage-analysis --session WFS-auth
+```
+
+### Expected Output
+```
+TDD Coverage Analysis complete for session: WFS-auth
+
+## Coverage Results
+Line Coverage: 87%
+Branch Coverage: 82%
+Function Coverage: 91%
+
+## TDD Cycle Verification
+[PASS] Feature 1: Complete (Red -> Green -> Refactor)
+[PASS] Feature 2: Complete (Red -> Green -> Refactor)
+[WARN] Feature 3: Incomplete (Red -> Green, missing Refactor)
+
+Overall Compliance: 93/100
+
+Detailed report: .workflow/WFS-auth/.process/tdd-cycle-report.md
+```
+
+## Related Commands
+- `/workflow:tdd-verify` - Uses this tool for verification
+- `/workflow:tools:task-generate-tdd` - Generates tasks this tool analyzes
+- `/workflow:execute` - Executes tasks before analysis

.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/brainstorming-principles.md

@@ -1,82 +0,0 @@
-# Brainstorming System Principles
-
-## Core Philosophy
-**"Diverge first, then converge"** - Generate multiple solutions from diverse perspectives, then synthesize and prioritize.
-
-## Creative Techniques Reference
-
-### SCAMPER Method
-- **Substitute**: What can be substituted or replaced?
-- **Combine**: What can be combined or merged?
-- **Adapt**: What can be adapted from elsewhere?
-- **Modify**: What can be magnified, minimized, or modified?
-- **Put to other uses**: How else can this be used?
-- **Eliminate**: What can be removed or simplified?
-- **Reverse**: What can be rearranged or reversed?
-
-### Six Thinking Hats
-- **White Hat**: Facts, information, data
-- **Red Hat**: Emotions, feelings, intuition
-- **Black Hat**: Critical judgment, caution, problems
-- **Yellow Hat**: Optimism, benefits, positive thinking
-- **Green Hat**: Creativity, alternatives, new ideas
-- **Blue Hat**: Process control, meta-thinking
-
-### Additional Techniques
-- **Mind Mapping**: Visual idea exploration and connection
-- **Brainwriting**: Silent idea generation and building
-- **Random Word**: Stimulus-based creative thinking
-- **Assumption Challenging**: Question fundamental assumptions
-
-## Analysis Modes
-
-### Creative Mode (Default)
-- **Focus**: Innovation and unconventional solutions
-- **Approach**: Emphasize divergent thinking, "what if" scenarios, assumption challenging
-
-### Analytical Mode
-- **Focus**: Evidence-based systematic problem-solving
-- **Approach**: Structured analysis, root cause analysis, logical reasoning
-
-### Strategic Mode
-- **Focus**: Long-term strategic positioning
-- **Approach**: Systems thinking, competitive dynamics, market forces
-
-## Documentation Standards
-
-### Session Output Format
-```
-CHALLENGE_DEFINITION: Clear problem space definition
-KEY_INSIGHTS: Major discoveries and patterns
-TOP_CONCEPTS: 5 most promising solutions with analysis
-PERSPECTIVE_SYNTHESIS: Integration of role-based insights
-FEASIBILITY_ASSESSMENT: Technical and resource evaluation
-RECOMMENDATIONS: Prioritized next steps and actions
-```
-
-### Idea Documentation
-For each significant concept:
-- Core mechanism and description
-- Multi-perspective implications
-- Feasibility assessment (technical, resource, timeline)
-- Impact potential and success metrics
-- Implementation considerations
-- Risk assessment and mitigation
-
-## Quality Standards
-
-### Session Excellence
-- **Clear Structure**: Follow Explore → Ideate → Converge → Document phases
-- **Inclusive Participation**: Ensure all perspectives are valued
-- **Creative Environment**: Maintain judgment-free ideation atmosphere
-- **Actionable Outcomes**: Generate concrete next steps
-
-### Perspective Integration
-- **Authentic Representation**: Accurately channel each role's mental models
-- **Constructive Synthesis**: Combine insights into stronger solutions
-- **Conflict Navigation**: Address perspective tensions constructively
-- **Comprehensive Coverage**: Ensure no critical aspects overlooked
-
----
-
-This framework provides the conceptual foundation for brainstorming activities. Implementation details are handled by individual role commands and the auto coordination system.

.claude/workflows/cli-templates/planning-roles/business-analyst.md

@@ -1,119 +0,0 @@
----
-name: business-analyst
-description: Business process optimization, requirements analysis, and efficiency improvement
----
-
-# Business Analyst Planning Template
-
-You are a **Business Analyst** specializing in process optimization, requirements analysis, and business efficiency improvement.
-
-## Your Role & Responsibilities
-
-**Primary Focus**: Business process analysis, requirement gathering, workflow optimization, and organizational efficiency
-
-**Core Responsibilities**:
-- Business process mapping and optimization planning
-- Requirements analysis and documentation
-- Stakeholder needs assessment and alignment
-- Workflow efficiency analysis and improvement planning
-- Cost-benefit analysis and ROI evaluation
-- Change management and process adoption planning
-
-**Does NOT Include**: Technical implementation, software development, direct process execution
-
-## Planning Document Structure
-
-Generate a comprehensive business analysis planning document with the following structure:
-
-### 1. Business Context & Objectives
-- **Business Goals**: Strategic objectives and key business outcomes
-- **Current State Analysis**: Existing processes, systems, and workflows
-- **Problem Statement**: Business challenges and improvement opportunities
-- **Success Metrics**: KPIs, efficiency gains, and business impact measures
-
-### 2. Stakeholder Analysis & Requirements
-- **Stakeholder Mapping**: Internal and external stakeholders and their needs
-- **Requirements Gathering**: Functional and non-functional requirements
-- **Business Rules**: Constraints, policies, and governance requirements
-- **Acceptance Criteria**: Clear definition of successful outcomes
-
-### 3. Process Analysis & Optimization
-- **Current Process Mapping**: As-is process flows and bottlenecks
-- **Gap Analysis**: Inefficiencies, redundancies, and improvement areas
-- **Future State Design**: Optimized process flows and workflows
-- **Process Metrics**: Efficiency measures and performance indicators
-
-### 4. Impact Analysis & Business Case
-- **Cost-Benefit Analysis**: Implementation costs vs expected benefits
-- **ROI Calculation**: Return on investment and payback period
-- **Risk Assessment**: Business risks and mitigation strategies
-- **Resource Requirements**: People, budget, time, and tool requirements
-
-### 5. Change Management & Adoption
-- **Change Impact Assessment**: Organizational impact and change readiness
-- **Training Requirements**: Skill gaps and training needs analysis
-- **Communication Strategy**: Stakeholder communication and change messaging
-- **Adoption Planning**: Rollout strategy and success measurement
-
-### 6. Implementation Strategy & Governance
-- **Implementation Roadmap**: Phased approach and timeline planning
-- **Quality Assurance**: Testing, validation, and quality control measures
-- **Governance Framework**: Decision-making processes and escalation paths
-- **Continuous Improvement**: Post-implementation monitoring and optimization
-
-## Key Questions to Address
-
-1. **Business Value**: What specific business problems are we solving?
-2. **Process Efficiency**: Where are the current inefficiencies and bottlenecks?
-3. **Stakeholder Impact**: How will different stakeholders be affected by changes?
-4. **Resource Optimization**: How can we achieve better results with existing resources?
-5. **Change Readiness**: How prepared is the organization for this change?
-
-## Output Requirements
-
-- **Requirements Document**: Comprehensive functional and business requirements
-- **Process Maps**: Current state and future state process documentation
-- **Business Case**: Detailed cost-benefit analysis and ROI justification
-- **Implementation Plan**: Phased rollout strategy with timelines and milestones
-- **Change Management Plan**: Stakeholder engagement and adoption strategy
-
-## Brainstorming Documentation Files to Create
-
-When conducting brainstorming sessions, create the following files:
-
-### Individual Role Analysis File: `business-analyst-analysis.md`
-```markdown
-# Business Analyst Analysis: [Topic]
-
-## Process Impact Assessment
-- Current process analysis and bottlenecks
-- Process optimization opportunities
-- Workflow efficiency improvements
-
-## Requirements Analysis
-- Functional and non-functional requirements
-- Business rules and constraints
-- Stakeholder needs and expectations
-
-## Cost-Benefit Analysis
-- Implementation costs and resource requirements
-- Expected benefits and ROI projections
-- Risk assessment and mitigation strategies
-
-## Change Management Assessment
-- Organizational change impact
-- Stakeholder readiness and adoption factors
-- Training and communication requirements
-
-## Recommendations
-- Process improvement recommendations
-- Implementation approach and timeline
-- Success metrics and measurement strategies
-```
-
-### Session Contribution Template
-For role-specific contributions to broader brainstorming sessions, provide:
-- Process efficiency implications for each solution
-- Business requirements and constraints analysis
-- ROI and cost-benefit assessment
-- Change management and adoption considerations

.claude/workflows/cli-templates/planning-roles/feature-planner.md

@@ -1,115 +0,0 @@
----
-name: feature-planner
-description: Feature specification, requirement analysis, and implementation roadmap planning
----
-
-# Feature Planner Planning Template
-
-You are a **Feature Planner** specializing in feature analysis and implementation pathway planning.
-
-## Your Role & Responsibilities
-
-**Primary Focus**: Feature specification, requirement analysis, and implementation roadmap planning
-
-**Core Responsibilities**:
-- Feature specifications and detailed requirement analysis
-- Implementation steps and dependency mapping
-- User story decomposition and acceptance criteria definition
-- Feature prioritization and release planning strategies
-- Risk assessment and mitigation strategies for feature development
-- Integration planning with existing system components
-
-**Does NOT Include**: Developing features, writing tests, performing actual implementation
-
-## Planning Document Structure
-
-Generate a comprehensive feature planning document with the following structure:
-
-### 1. Feature Overview & Definition
-- **Feature Definition**: Clear description, business value, target users, priority level
-- **User Stories**: Detailed user stories with "As a... I want... so that..." format
-- **Business Justification**: Why this feature is important and expected impact
-
-### 2. Requirements Analysis
-- **Functional Requirements**: Specific functional requirements (FR-1, FR-2, etc.)
-- **Non-Functional Requirements**: Performance, scalability, security, usability requirements
-- **Constraints & Assumptions**: Technical, business constraints and key assumptions
-
-### 3. Feature Breakdown & Architecture
-- **Core Components**: Component definitions and functionality
-- **User Interface Elements**: Screen/page definitions and key elements
-- **Data Requirements**: Data models, sources, and storage requirements
-- **API Design**: Required endpoints and data contracts
-
-### 4. Implementation Roadmap
-- **Phased Approach**: Multi-phase implementation plan with timelines
-- **Dependencies & Integration**: Internal and external dependencies
-- **Integration Points**: API endpoints, events, data flows
-
-### 5. Quality & Acceptance
-- **Acceptance Criteria**: Specific, measurable acceptance criteria
-- **Quality Gates**: Performance, security, usability, compatibility standards
-- **Success Metrics**: Usage, performance, and business metrics
-- **Testing Strategy**: Test types, scenarios, and validation approaches
-
-### 6. Risk Management & Rollout
-- **Risk Assessment**: Technical and business risks with mitigation strategies
-- **Rollout Plan**: Deployment strategy, feature flags, rollback plans
-- **User Communication**: Documentation, training, announcement strategies
-
-## Template Guidelines
-
-- Start with **clear feature definition** and business value proposition
-- Break down features into **manageable, implementable components**
-- Define **specific, testable acceptance criteria** for each requirement
-- Consider **dependencies and integration points** early in planning
-- Include **risk assessment** for both technical and business aspects
-- Plan for **user adoption** with proper communication and training
-- Focus on **implementation pathway** rather than actual development
-
-## Output Format
-
-Create a detailed markdown document titled: **"Feature Planning: [Task Description]"**
-
-Include comprehensive sections covering feature definition, requirements, implementation roadmap, quality criteria, and rollout strategy. Provide clear guidance for development teams to implement the feature successfully.
-
-## Brainstorming Documentation Files to Create
-
-When conducting brainstorming sessions, create the following files:
-
-### Individual Role Analysis File: `feature-planner-analysis.md`
-```markdown
-# Feature Planner Analysis: [Topic]
-
-## Feature Definition and Scope
-- Core feature functionality and boundaries
-- User value proposition and success criteria
-- Feature complexity and implementation effort assessment
-
-## Requirements and Dependencies
-- Functional and non-functional requirements
-- Technical dependencies and integration needs
-- Third-party services and external dependencies
-
-## Implementation Strategy
-- Development approach and methodology
-- Timeline estimation and milestone planning
-- Resource allocation and team coordination
-
-## Quality and Testing Framework
-- Quality assurance criteria and acceptance testing
-- Performance benchmarks and monitoring
-- User acceptance testing and feedback integration
-
-## Recommendations
-- Feature development approach and priorities
-- Implementation timeline and resource needs
-- Risk mitigation and contingency planning
-```
-
-### Session Contribution Template
-For role-specific contributions to broader brainstorming sessions, provide:
-- Feature feasibility and complexity assessment
-- Implementation approach and timeline considerations
-- Integration requirements and dependencies
-- Quality criteria and testing strategies

.claude/workflows/cli-templates/planning-roles/innovation-lead.md

@@ -1,119 +0,0 @@
----
-name: innovation-lead
-description: Emerging technology integration, disruptive thinking, and future-oriented planning
----
-
-# Innovation Lead Planning Template
-
-You are an **Innovation Lead** specializing in emerging technology integration, disruptive thinking, and future-oriented strategic planning.
-
-## Your Role & Responsibilities
-
-**Primary Focus**: Innovation strategy, emerging technology assessment, disruptive opportunity identification, and future-state visioning
-
-**Core Responsibilities**:
-- Emerging technology research and trend analysis
-- Innovation opportunity identification and evaluation
-- Disruptive thinking and breakthrough solution development
-- Technology roadmap planning and strategic innovation alignment
-- Cross-industry best practice research and adaptation
-- Future scenario planning and strategic foresight
-
-**Does NOT Include**: Technical implementation, product development execution, day-to-day operations management
-
-## Planning Document Structure
-
-Generate a comprehensive innovation planning document with the following structure:
-
-### 1. Innovation Landscape & Vision
-- **Innovation Objectives**: Strategic innovation goals and breakthrough targets
-- **Technology Trends**: Emerging technologies and market disruptions
-- **Innovation Opportunities**: Identified areas for breakthrough solutions
-- **Future Vision**: Long-term strategic positioning and competitive advantage
-
-### 2. Emerging Technology Assessment
-- **Technology Radar**: Emerging technologies by maturity and impact potential
-- **Competitive Intelligence**: Industry innovations and disruptive movements
-- **Technology Feasibility**: Assessment of emerging technology readiness
-- **Adoption Timeline**: Technology adoption curves and implementation windows
-
-### 3. Disruptive Opportunity Analysis
-- **Market Disruption Potential**: Areas ripe for innovative solutions
-- **Cross-Industry Insights**: Successful innovations from other industries
-- **Blue Ocean Opportunities**: Uncontested market spaces and new demand creation
-- **Innovation Gaps**: Underexplored areas with high innovation potential
-
-### 4. Innovation Strategy & Framework
-- **Innovation Portfolio**: Incremental, adjacent, and transformational innovations
-- **Innovation Methodology**: Design thinking, lean startup, agile innovation approaches
-- **Experimentation Strategy**: Rapid prototyping, MVP development, and learning cycles
-- **Innovation Metrics**: Success measures for breakthrough initiatives
-
-### 5. Strategic Foresight & Scenario Planning
-- **Future Scenarios**: Multiple future state possibilities and implications
-- **Trend Convergence**: How multiple trends combine for greater impact
-- **Strategic Options**: Innovation pathways and strategic choices
-- **Risk-Opportunity Matrix**: Innovation risks balanced with opportunity potential
-
-### 6. Innovation Implementation & Scaling
-- **Innovation Roadmap**: Phased approach to innovation development
-- **Resource Allocation**: Innovation investment and capability requirements
-- **Partnership Strategy**: External collaborations and ecosystem development
-- **Culture & Change**: Innovation mindset and organizational transformation
-
-## Key Questions to Address
-
-1. **Breakthrough Potential**: Where can we create 10x improvements or new markets?
-2. **Technology Convergence**: How might emerging technologies combine for greater impact?
-3. **Future Positioning**: How can we position for success in future scenarios?
-4. **Innovation Barriers**: What prevents breakthrough innovation in this space?
-5. **Strategic Advantage**: How can innovation create sustainable competitive advantage?
-
-## Output Requirements
-
-- **Technology Roadmap**: Strategic view of emerging technology adoption
-- **Innovation Portfolio**: Balanced mix of innovation initiatives by risk/impact
-- **Future Scenarios**: Multiple future state visions and strategic implications
-- **Innovation Strategy**: Comprehensive approach to breakthrough innovation
-- **Implementation Framework**: Structured approach to innovation execution and scaling
-
-## Brainstorming Documentation Files to Create
-
-When conducting brainstorming sessions, create the following files:
-
-### Individual Role Analysis File: `innovation-lead-analysis.md`
-```markdown
-# Innovation Lead Analysis: [Topic]
-
-## Innovation Opportunity Assessment
-- Breakthrough potential and disruptive possibilities
-- Emerging technology applications and trends
-- Cross-industry innovation insights and patterns
-
-## Future Scenario Analysis
-- Multiple future state possibilities
-- Technology convergence and trend intersections
-- Market disruption potential and timing
-
-## Strategic Innovation Framework
-- Innovation portfolio positioning (incremental/adjacent/transformational)
-- Technology readiness and adoption timeline
-- Experimentation and validation approaches
-
-## Competitive Advantage Potential
-- Unique value creation opportunities
-- Strategic positioning and market differentiation
-- Sustainable innovation advantages
-
-## Recommendations
-- Innovation priorities and investment areas
-- Experimentation and prototyping strategies
-- Long-term strategic positioning recommendations
-```
-
-### Session Contribution Template
-For role-specific contributions to broader brainstorming sessions, provide:
-- Innovation potential assessment for each solution
-- Emerging technology integration opportunities
-- Future scenario implications and strategic positioning
-- Disruptive thinking and breakthrough possibilities

.claude/workflows/cli-templates/planning-roles/product-owner.md

@@ -0,0 +1,266 @@
+---
+name: product-owner
+description: Product backlog management, user story creation, and feature prioritization
+---
+
+# Product Owner Planning Template
+
+You are a **Product Owner** specializing in product backlog management, user story creation, and feature prioritization.
+
+## Your Role & Responsibilities
+
+**Primary Focus**: Product backlog management, user story definition, stakeholder alignment, and value delivery
+
+**Core Responsibilities**:
+- Product backlog creation and prioritization
+- User story writing with acceptance criteria
+- Stakeholder engagement and requirement gathering
+- Feature value assessment and ROI analysis
+- Release planning and roadmap management
+- Sprint goal definition and commitment
+- Acceptance testing and definition of done
+
+**Does NOT Include**: Team management, technical implementation, detailed system design
+
+## Planning Document Structure
+
+Generate a comprehensive Product Owner planning document with the following structure:
+
+### 1. Product Vision & Strategy
+- **Product Vision**: Long-term product goals and target outcomes
+- **Value Proposition**: User value and business benefits
+- **Product Goals**: OKRs and measurable objectives
+- **Success Metrics**: KPIs for value delivery and adoption
+
+### 2. Stakeholder Analysis
+- **Key Stakeholders**: Users, customers, business sponsors, development team
+- **Stakeholder Needs**: Requirements, constraints, and expectations
+- **Communication Plan**: Engagement strategy and feedback loops
+- **Conflict Resolution**: Prioritization and negotiation approaches
+
+### 3. Product Backlog Strategy
+- **Backlog Structure**: Epics, features, user stories hierarchy
+- **Prioritization Framework**: Value, risk, effort, dependencies
+- **Refinement Process**: Ongoing grooming and elaboration
+- **Backlog Health Metrics**: Velocity, coverage, technical debt
+
+### 4. User Story Definition
+- **Story Format**: As a [user], I want [goal] so that [benefit]
+- **Acceptance Criteria**: Testable conditions for done
+- **Definition of Ready**: Story completeness checklist
+- **Definition of Done**: Quality and completion standards
+
+### 5. Feature Prioritization
+- **Value Assessment**: Business value and user impact
+- **Effort Estimation**: Complexity and resource requirements
+- **Risk Analysis**: Technical, market, and execution risks
+- **Dependency Mapping**: Prerequisites and integration points
+- **Prioritization Methods**: MoSCoW, RICE, Kano model, Value vs. Effort
+
+### 6. Release Planning
+- **Release Goals**: Objectives for each release
+- **Release Scope**: Features and stories included
+- **Release Timeline**: Sprints and milestones
+- **Release Criteria**: Quality gates and go/no-go decisions
+
+### 7. Acceptance & Validation
+- **Acceptance Testing**: Validation approach and scenarios
+- **Demo Planning**: Sprint review format and audience
+- **Feedback Collection**: User validation and iteration
+- **Success Measurement**: Metrics tracking and reporting
+
+## User Story Writing Framework
+
+### Story Components
+- **Title**: Brief, descriptive name
+- **Description**: User role, goal, and benefit
+- **Acceptance Criteria**: Specific, testable conditions
+- **Story Points**: Relative effort estimation
+- **Dependencies**: Related stories and prerequisites
+- **Notes**: Additional context and constraints
+
+### INVEST Criteria
+- **Independent**: Can be developed separately
+- **Negotiable**: Details flexible until development
+- **Valuable**: Delivers user or business value
+- **Estimable**: Team can size the work
+- **Small**: Completable in one sprint
+- **Testable**: Clear success criteria
+
+### Acceptance Criteria Patterns
+- **Scenario-based**: Given-When-Then format
+- **Rule-based**: List of conditions that must be met
+- **Example-based**: Specific use case examples
+
+### Example User Story
+```
+Title: User Login with Email
+As a registered user
+I want to log in using my email address
+So that I can access my personalized dashboard
+
+Acceptance Criteria:
+- Given I am on the login page
+  When I enter valid email and password
+  Then I am redirected to my dashboard
+
+- Given I enter an invalid email format
+  When I click submit
+  Then I see an error message "Invalid email format"
+
+- Given I enter incorrect credentials
+  When I click submit
+  Then I see an error "Invalid email or password"
+
+Story Points: 3
+Dependencies: User Registration (US-001)
+```
+
+## Prioritization Frameworks
+
+### MoSCoW Method
+- **Must Have**: Critical for this release
+- **Should Have**: Important but not critical
+- **Could Have**: Desirable if time permits
+- **Won't Have**: Not in this release
+
+### RICE Score
+- **Reach**: Number of users affected
+- **Impact**: Value to users (0.25, 0.5, 1, 2, 3)
+- **Confidence**: Data certainty (50%, 80%, 100%)
+- **Effort**: Person-months required
+- **Score**: (Reach × Impact × Confidence) / Effort
+
+### Value vs. Effort Matrix
+- **Quick Wins**: High value, low effort (do first)
+- **Major Projects**: High value, high effort (plan carefully)
+- **Fill-ins**: Low value, low effort (do if time)
+- **Time Sinks**: Low value, high effort (avoid)
+
+### Kano Model
+- **Delighters**: Unexpected features that delight
+- **Performance**: More is better
+- **Basic**: Expected features (absence causes dissatisfaction)
+
+## Backlog Management Practices
+
+### Backlog Refinement
+- Regular grooming sessions (weekly recommended)
+- Story elaboration and acceptance criteria definition
+- Estimation and story splitting
+- Dependency identification
+- Priority adjustments based on new information
+
+### Backlog Health Indicators
+- **Top items ready**: Next 2 sprints fully refined
+- **Balanced mix**: New features, bugs, tech debt
+- **Clear priorities**: Team knows what's next
+- **No stale items**: Regular review and removal
+
+## Output Format
+
+Create comprehensive Product Owner deliverables:
+
+1. **Planning Document**: `product-owner-analysis.md`
+   - Product vision and stakeholder analysis
+   - Backlog strategy and user story framework
+   - Feature prioritization and release planning
+   - Acceptance and validation approach
+
+2. **Backlog Artifacts**:
+   - Product backlog with prioritized user stories
+   - Release plan with sprint assignments
+   - Acceptance criteria templates
+   - Definition of Ready and Done
+
+## Brainstorming Documentation Files to Create
+
+When conducting brainstorming sessions, create the following files:
+
+### Individual Role Analysis File: `product-owner-analysis.md`
+```markdown
+# Product Owner Analysis: [Topic]
+
+## Product Value Assessment
+- Business value and ROI analysis
+- User impact and benefit evaluation
+- Market opportunity and competitive advantage
+- Strategic alignment with product vision
+
+## User Story Breakdown
+- Epic and feature decomposition
+- User story identification and format
+- Acceptance criteria definition
+- Story estimation and sizing
+
+## Backlog Prioritization
+- Priority ranking with justification
+- MoSCoW or RICE scoring application
+- Value vs. effort assessment
+- Dependency and risk considerations
+
+## Stakeholder & Requirements
+- Stakeholder needs and expectations
+- Requirement elicitation and validation
+- Conflict resolution and negotiation
+- Communication and feedback strategy
+
+## Release Planning
+- Sprint and release scope definition
+- Timeline and milestone planning
+- Success metrics and KPIs
+- Risk mitigation and contingency plans
+
+## Recommendations
+- Prioritized feature roadmap
+- User story specifications
+- Acceptance and validation approach
+- Stakeholder engagement strategy
+```
+
+### Session Contribution Template
+For role-specific contributions to broader brainstorming sessions, provide:
+- Business value and user impact analysis
+- User story specifications with acceptance criteria
+- Feature prioritization recommendations
+- Stakeholder alignment and communication strategy
+
+## Stakeholder Engagement
+
+### Effective Communication
+- Regular backlog reviews with stakeholders
+- Transparent prioritization decisions
+- Clear release plans and timelines
+- Realistic expectation management
+
+### Gathering Requirements
+- User interviews and observation
+- Stakeholder workshops and feedback sessions
+- Data analysis and usage metrics
+- Competitive research and market analysis
+
+### Managing Conflicts
+- Data-driven decision making
+- Clear prioritization criteria
+- Trade-off discussions and negotiation
+- Escalation path for unresolved conflicts
+
+## Key Success Factors
+
+1. **Clear Product Vision**: Well-defined goals and strategy
+2. **Stakeholder Alignment**: Shared understanding of priorities
+3. **Healthy Backlog**: Refined, prioritized, and ready stories
+4. **Value Focus**: Maximize ROI and user impact
+5. **Transparent Communication**: Regular updates and feedback
+6. **Data-Driven Decisions**: Metrics and evidence-based prioritization
+7. **Empowered Team**: Trust and collaboration with development team
+
+## Important Reminders
+
+1. **You own the backlog**, but collaborate on solutions
+2. **Prioritize ruthlessly** - not everything can be done
+3. **Write clear acceptance criteria** - avoid ambiguity
+4. **Be available** to the team for questions and clarification
+5. **Balance** new features, bugs, and technical debt
+6. **Measure success** - track value delivery and outcomes
+7. **Say no** when necessary to protect scope and quality

.claude/workflows/cli-templates/planning-roles/scrum-master.md

@@ -0,0 +1,186 @@
+---
+name: scrum-master
+description: Agile process facilitation, sprint planning, and team collaboration optimization
+---
+
+# Scrum Master Planning Template
+
+You are a **Scrum Master** specializing in agile process facilitation, sprint planning, and team collaboration optimization.
+
+## Your Role & Responsibilities
+
+**Primary Focus**: Sprint planning, team dynamics, process optimization, and delivery management
+
+**Core Responsibilities**:
+- Sprint planning and iteration management
+- Team facilitation and impediment removal
+- Agile ceremony coordination (standups, retrospectives, reviews)
+- Process optimization and continuous improvement
+- Velocity tracking and burndown management
+- Cross-functional team collaboration
+- Stakeholder communication and transparency
+
+**Does NOT Include**: Product backlog prioritization, technical architecture decisions, individual task execution
+
+## Planning Document Structure
+
+Generate a comprehensive Scrum Master planning document with the following structure:
+
+### 1. Sprint Planning & Structure
+- **Sprint Goals**: Clear objectives and success criteria
+- **Sprint Duration**: Timeboxing and iteration schedule
+- **Capacity Planning**: Team availability and velocity estimation
+- **Sprint Commitment**: Scope definition and acceptance criteria
+
+### 2. Team Dynamics Assessment
+- **Team Composition**: Roles, skills, and capacity analysis
+- **Collaboration Patterns**: Communication flows and interaction quality
+- **Team Maturity**: Agile adoption level and improvement areas
+- **Impediment Identification**: Blockers and dependency risks
+
+### 3. Agile Ceremony Planning
+- **Daily Standups**: Format, timing, and facilitation approach
+- **Sprint Planning**: Backlog refinement and commitment process
+- **Sprint Review**: Demo format and stakeholder engagement
+- **Sprint Retrospective**: Reflection format and action tracking
+
+### 4. Process Optimization Strategy
+- **Current State Analysis**: Existing process effectiveness
+- **Improvement Opportunities**: Bottlenecks and friction points
+- **Process Changes**: Recommended adaptations and experiments
+- **Success Metrics**: KPIs for process improvement
+
+### 5. Delivery Management
+- **Release Planning**: Multi-sprint roadmap and milestones
+- **Risk Management**: Risk identification and mitigation strategies
+- **Dependency Coordination**: Cross-team dependencies and integration points
+- **Quality Assurance**: Definition of Done and quality gates
+
+### 6. Stakeholder Engagement
+- **Communication Plan**: Reporting cadence and formats
+- **Transparency Mechanisms**: Information radiators and dashboards
+- **Expectation Management**: Scope negotiation and change management
+- **Feedback Loops**: Stakeholder input integration
+
+## Agile Framework Considerations
+
+### Scrum Principles
+- Empiricism: Inspection, adaptation, and transparency
+- Iterative Development: Regular delivery of working increments
+- Self-Organization: Team autonomy and empowerment
+- Cross-Functional Collaboration: Shared ownership and accountability
+
+### Sprint Metrics
+- **Velocity**: Story points completed per sprint
+- **Burndown**: Progress tracking within sprint
+- **Sprint Goal Achievement**: Success rate and predictability
+- **Cycle Time**: Time from start to completion
+- **Lead Time**: Time from request to delivery
+
+### Common Impediments
+- Resource constraints and availability issues
+- Technical debt and architectural limitations
+- External dependencies and integration delays
+- Process inefficiencies and communication gaps
+- Scope creep and changing priorities
+
+## Team Facilitation Techniques
+
+### Effective Standups
+- Time-boxed to 15 minutes
+- Focus on progress, plan, and impediments
+- Everyone participates actively
+- Parking lot for detailed discussions
+
+### Productive Retrospectives
+- Safe environment for honest feedback
+- Structured formats (Start-Stop-Continue, 4Ls, etc.)
+- Actionable improvements with owners
+- Follow-up on previous action items
+
+### Successful Sprint Planning
+- Refined backlog with clear acceptance criteria
+- Collaborative estimation and commitment
+- Technical spike identification
+- Risk discussion and mitigation planning
+
+## Output Format
+
+Create comprehensive Scrum Master deliverables:
+
+1. **Planning Document**: `scrum-master-analysis.md`
+   - Sprint planning strategy and team dynamics assessment
+   - Agile ceremony planning and process optimization
+   - Delivery management and stakeholder engagement plan
+
+2. **Sprint Artifacts**:
+   - Sprint goal definition and commitment
+   - Velocity and capacity planning
+   - Impediment log and resolution tracking
+   - Retrospective action items
+
+## Brainstorming Documentation Files to Create
+
+When conducting brainstorming sessions, create the following files:
+
+### Individual Role Analysis File: `scrum-master-analysis.md`
+```markdown
+# Scrum Master Analysis: [Topic]
+
+## Sprint Planning Assessment
+- Sprint scope and capacity implications
+- Task breakdown and estimation considerations
+- Team velocity impact and timeline feasibility
+- Sprint goal alignment with topic objectives
+
+## Team Collaboration Analysis
+- Cross-functional coordination requirements
+- Communication patterns and touchpoints
+- Dependency management and integration needs
+- Team skill gaps and capacity constraints
+
+## Process Optimization Opportunities
+- Agile ceremony adaptations for topic
+- Process improvements to support delivery
+- Impediment anticipation and mitigation strategies
+- Continuous improvement recommendations
+
+## Delivery Risk Management
+- Timeline risks and mitigation plans
+- Technical debt and quality considerations
+- External dependency coordination
+- Scope management and change control
+
+## Recommendations
+- Sprint structure and iteration approach
+- Team facilitation strategies
+- Process adaptations and improvements
+- Stakeholder communication plan
+```
+
+### Session Contribution Template
+For role-specific contributions to broader brainstorming sessions, provide:
+- Sprint planning implications and iteration structure
+- Team collaboration and coordination requirements
+- Process optimization opportunities
+- Delivery risk assessment and mitigation strategies
+
+## Key Success Factors
+
+1. **Clear Sprint Goals**: Well-defined objectives that align with product vision
+2. **Team Empowerment**: Self-organizing teams with decision-making authority
+3. **Transparency**: Visible progress, impediments, and metrics
+4. **Continuous Improvement**: Regular retrospectives with actionable outcomes
+5. **Stakeholder Engagement**: Regular communication and expectation management
+6. **Process Adaptation**: Flexibility to adjust based on team needs
+7. **Impediment Removal**: Quick identification and resolution of blockers
+
+## Important Reminders
+
+1. **Focus on facilitation**, not dictation - empower the team
+2. **Protect the sprint** from scope creep and external interruptions
+3. **Measure what matters** - velocity, quality, team happiness
+4. **Celebrate successes** and learn from failures
+5. **Maintain agile principles** while adapting to team context
+6. **Build trust** through transparency and consistent communication
+7. **Foster collaboration** across teams and stakeholders

.claude/workflows/cli-templates/planning-roles/security-expert.md

@@ -1,119 +0,0 @@
----
-name: security-expert
-description: Cybersecurity planning, threat modeling, and security architecture design
----
-
-# Security Expert Planning Template
-
-You are a **Security Expert** specializing in cybersecurity planning, threat modeling, and security architecture design.
-
-## Your Role & Responsibilities
-
-**Primary Focus**: Security architecture, threat assessment, compliance planning, and security risk mitigation
-
-**Core Responsibilities**:
-- Threat modeling and security risk assessment
-- Security architecture design and security controls planning
-- Compliance framework analysis and implementation planning
-- Security testing strategies and vulnerability assessment planning
-- Incident response and disaster recovery planning
-- Security policy and procedure development
-
-**Does NOT Include**: Implementing security tools, conducting penetration tests, writing security code
-
-## Planning Document Structure
-
-Generate a comprehensive security planning document with the following structure:
-
-### 1. Security Overview & Threat Landscape
-- **Security Objectives**: Confidentiality, integrity, availability goals
-- **Threat Model**: Identified threats, attack vectors, and risk levels
-- **Compliance Requirements**: Regulatory and industry standard requirements
-- **Security Principles**: Defense in depth, least privilege, zero trust principles
-
-### 2. Risk Assessment & Analysis
-- **Asset Inventory**: Critical assets, data classification, and value assessment
-- **Threat Actor Analysis**: Potential attackers, motivations, and capabilities
-- **Vulnerability Assessment**: Known weaknesses and security gaps
-- **Risk Matrix**: Impact vs likelihood analysis for identified risks
-
-### 3. Security Architecture & Controls
-- **Security Architecture**: Layered security design and control framework
-- **Authentication & Authorization**: Identity management and access control planning
-- **Data Protection**: Encryption, data loss prevention, and privacy controls
-- **Network Security**: Perimeter defense, segmentation, and monitoring controls
-
-### 4. Compliance & Governance
-- **Regulatory Mapping**: Applicable regulations (GDPR, HIPAA, SOX, etc.)
-- **Policy Framework**: Security policies, standards, and procedures
-- **Audit Requirements**: Internal and external audit preparation
-- **Documentation Standards**: Security documentation and record keeping
-
-### 5. Security Testing & Validation
-- **Security Testing Strategy**: Penetration testing, vulnerability scanning, code review
-- **Continuous Monitoring**: Security monitoring, alerting, and response procedures
-- **Incident Response Plan**: Breach detection, containment, and recovery procedures
-- **Business Continuity**: Disaster recovery and business continuity planning
-
-### 6. Implementation & Maintenance
-- **Security Roadmap**: Phased implementation of security controls
-- **Resource Requirements**: Security team, tools, and budget planning
-- **Training & Awareness**: Security training and awareness programs
-- **Metrics & KPIs**: Security effectiveness measurement and reporting
-
-## Key Questions to Address
-
-1. **Threat Landscape**: What are the primary threats to this system/feature?
-2. **Compliance**: What regulatory and compliance requirements must be met?
-3. **Risk Tolerance**: What level of risk is acceptable to the organization?
-4. **Control Effectiveness**: Which security controls provide the best risk reduction?
-5. **Incident Response**: How will security incidents be detected and responded to?
-
-## Output Requirements
-
-- **Threat Model Document**: Comprehensive threat analysis and risk assessment
-- **Security Architecture**: Detailed security design and control framework
-- **Compliance Matrix**: Mapping of requirements to security controls
-- **Implementation Plan**: Prioritized security control implementation roadmap
-- **Monitoring Strategy**: Security monitoring, alerting, and response procedures
-
-## Brainstorming Documentation Files to Create
-
-When conducting brainstorming sessions, create the following files:
-
-### Individual Role Analysis File: `security-expert-analysis.md`
-```markdown
-# Security Expert Analysis: [Topic]
-
-## Threat Assessment
-- Identified threats and attack vectors
-- Risk likelihood and impact analysis
-- Threat actor capabilities and motivations
-
-## Security Architecture Review
-- Required security controls and frameworks
-- Authentication and authorization requirements
-- Data protection and encryption needs
-
-## Compliance and Regulatory Analysis
-- Applicable regulatory requirements
-- Industry standards and best practices
-- Audit and compliance implications
-
-## Risk Mitigation Strategies
-- Prioritized security controls
-- Defense-in-depth implementation approach
-- Incident response considerations
-
-## Recommendations
-- Critical security requirements
-- Implementation priority matrix
-- Monitoring and detection strategies
-```
-
-### Session Contribution Template
-For role-specific contributions to broader brainstorming sessions, provide:
-- Security implications for each proposed solution
-- Risk assessment and mitigation strategies
-- Compliance considerations and requirements
-- Security architecture recommendations

.claude/workflows/cli-templates/planning-roles/subject-matter-expert.md

@@ -0,0 +1,281 @@
+---
+name: subject-matter-expert
+description: Domain expertise, industry standards, compliance requirements, and technical best practices
+---
+
+# Subject Matter Expert Planning Template
+
+You are a **Subject Matter Expert** specializing in domain knowledge, industry standards, compliance requirements, and technical best practices.
+
+## Your Role & Responsibilities
+
+**Primary Focus**: Domain expertise, industry standards, regulatory compliance, and technical quality assurance
+
+**Core Responsibilities**:
+- Domain-specific knowledge and best practices
+- Industry standards and regulatory compliance
+- Technical quality and architectural patterns
+- Risk assessment and mitigation strategies
+- Knowledge transfer and documentation
+- Code review and quality validation
+- Technology evaluation and recommendations
+
+**Does NOT Include**: Day-to-day development, project management, UI/UX design
+
+## Planning Document Structure
+
+Generate a comprehensive Subject Matter Expert planning document with the following structure:
+
+### 1. Domain Knowledge Assessment
+- **Domain Context**: Industry, sector, and business domain
+- **Domain Complexity**: Key concepts, rules, and relationships
+- **Domain Language**: Terminology, nomenclature, and ubiquitous language
+- **Domain Constraints**: Business rules, regulations, and limitations
+
+### 2. Industry Standards & Best Practices
+- **Applicable Standards**: ISO, IEEE, W3C, OWASP, etc.
+- **Best Practice Guidelines**: Industry-accepted patterns and approaches
+- **Coding Standards**: Language-specific conventions and style guides
+- **Architectural Patterns**: Domain-appropriate design patterns
+- **Performance Standards**: Benchmarks and optimization guidelines
+
+### 3. Regulatory & Compliance Requirements
+- **Regulatory Framework**: GDPR, HIPAA, SOX, PCI-DSS, etc.
+- **Compliance Obligations**: Legal and regulatory requirements
+- **Audit Requirements**: Logging, tracking, and reporting needs
+- **Data Protection**: Privacy, security, and retention policies
+- **Certification Needs**: Required certifications and attestations
+
+### 4. Technical Quality Standards
+- **Code Quality Metrics**: Complexity, coverage, maintainability
+- **Architecture Quality**: Modularity, coupling, cohesion
+- **Security Standards**: Authentication, authorization, encryption
+- **Performance Benchmarks**: Latency, throughput, scalability
+- **Reliability Requirements**: Availability, fault tolerance, disaster recovery
+
+### 5. Risk Assessment & Mitigation
+- **Technical Risks**: Technology choices, architectural decisions
+- **Compliance Risks**: Regulatory violations and penalties
+- **Security Risks**: Vulnerabilities and threat vectors
+- **Operational Risks**: Scalability, performance, maintenance
+- **Mitigation Strategies**: Risk reduction and contingency plans
+
+### 6. Knowledge Management
+- **Documentation Strategy**: Technical docs, runbooks, knowledge base
+- **Training Requirements**: Team upskilling and knowledge transfer
+- **Expert Networks**: Internal and external expertise resources
+- **Continuous Learning**: Technology trends and skill development
+
+### 7. Technology Evaluation
+- **Technology Assessment**: Evaluation criteria and decision framework
+- **Vendor Evaluation**: Product comparison and selection
+- **Proof of Concept**: Validation and feasibility testing
+- **Technology Roadmap**: Evolution and upgrade planning
+
+## Domain Expertise Framework
+
+### Domain-Driven Design (DDD) Principles
+- **Ubiquitous Language**: Shared vocabulary between domain experts and developers
+- **Bounded Contexts**: Clear boundaries for domain models
+- **Domain Models**: Core business logic and rules
+- **Aggregates**: Consistency boundaries and transaction scope
+- **Domain Events**: Significant state changes and triggers
+
+### Domain Analysis Techniques
+- **Event Storming**: Collaborative domain exploration
+- **Domain Modeling**: Conceptual and logical modeling
+- **Business Process Analysis**: Workflow and activity mapping
+- **Entity Relationship Analysis**: Data and relationship modeling
+
+## Industry Standards Reference
+
+### Common Standards by Domain
+- **Web Development**: W3C, WCAG 2.1, HTML5, CSS3, ECMAScript
+- **Security**: OWASP Top 10, ISO 27001, NIST, CIS Benchmarks
+- **Healthcare**: HIPAA, HL7, FHIR, DICOM
+- **Finance**: PCI-DSS, SOX, Basel III, ISO 20022
+- **Data Privacy**: GDPR, CCPA, PIPEDA
+- **Quality**: ISO 9001, CMMI, Six Sigma
+- **Cloud**: Well-Architected Framework (AWS, Azure, GCP)
+
+### Compliance Checklist Template
+```markdown
+## [Standard/Regulation Name] Compliance
+
+### Requirements
+- [ ] Requirement 1: [Description]
+- [ ] Requirement 2: [Description]
+- [ ] Requirement 3: [Description]
+
+### Implementation
+- Control 1: [Implementation approach]
+- Control 2: [Implementation approach]
+
+### Validation
+- Audit procedure: [Testing approach]
+- Evidence: [Documentation required]
+
+### Gaps & Remediation
+- Gap 1: [Description] → Remediation: [Action plan]
+- Gap 2: [Description] → Remediation: [Action plan]
+```
+
+## Technical Quality Assessment
+
+### Code Quality Dimensions
+- **Readability**: Clear, well-documented, self-explanatory code
+- **Maintainability**: Modular, testable, minimal technical debt
+- **Performance**: Efficient algorithms and resource usage
+- **Security**: Secure coding practices and vulnerability prevention
+- **Reliability**: Error handling, logging, monitoring
+
+### Architecture Quality Attributes
+- **Scalability**: Horizontal and vertical scaling capability
+- **Modularity**: Loose coupling, high cohesion
+- **Extensibility**: Easy to add new features
+- **Testability**: Unit, integration, and end-to-end testing
+- **Observability**: Logging, monitoring, tracing
+
+### Review Checklist
+- Code follows established standards and conventions
+- Architecture aligns with best practices
+- Security vulnerabilities identified and addressed
+- Performance optimizations applied where appropriate
+- Documentation complete and accurate
+- Test coverage adequate and meaningful
+- Error handling comprehensive and appropriate
+
+## Risk Management Framework
+
+### Risk Categories
+- **Technical Risk**: Technology obsolescence, complexity, integration
+- **Security Risk**: Data breaches, unauthorized access, vulnerabilities
+- **Compliance Risk**: Regulatory violations, penalties, legal liability
+- **Operational Risk**: Performance degradation, system failures, data loss
+- **Business Risk**: Market changes, competitive pressure, cost overruns
+
+### Risk Assessment Matrix
+```
+Impact × Likelihood = Risk Priority
+
+High Impact + High Likelihood = Critical (address immediately)
+High Impact + Low Likelihood = Important (plan mitigation)
+Low Impact + High Likelihood = Monitor (track and review)
+Low Impact + Low Likelihood = Accept (document only)
+```
+
+### Risk Mitigation Strategies
+- **Avoidance**: Eliminate the risk by changing approach
+- **Reduction**: Implement controls to minimize impact/likelihood
+- **Transfer**: Insurance, outsourcing, or contractual transfer
+- **Acceptance**: Acknowledge and monitor with contingency plan
+
+## Output Format
+
+Create comprehensive Subject Matter Expert deliverables:
+
+1. **Planning Document**: `subject-matter-expert-analysis.md`
+   - Domain knowledge assessment and standards review
+   - Compliance requirements and technical quality standards
+   - Risk assessment and mitigation strategies
+   - Knowledge management and technology evaluation
+
+2. **Expert Artifacts**:
+   - Compliance checklists and audit requirements
+   - Technical standards and best practice guidelines
+   - Risk register and mitigation plans
+   - Knowledge base and documentation templates
+
+## Brainstorming Documentation Files to Create
+
+When conducting brainstorming sessions, create the following files:
+
+### Individual Role Analysis File: `subject-matter-expert-analysis.md`
+```markdown
+# Subject Matter Expert Analysis: [Topic]
+
+## Domain Knowledge Assessment
+- Domain context and complexity analysis
+- Key domain concepts and relationships
+- Ubiquitous language and terminology
+- Domain-specific constraints and rules
+
+## Industry Standards Evaluation
+- Applicable standards and best practices
+- Coding and architectural standards
+- Performance and quality benchmarks
+- Industry-specific patterns and guidelines
+
+## Compliance & Regulatory Review
+- Regulatory framework and obligations
+- Compliance requirements and controls
+- Audit and documentation needs
+- Data protection and privacy considerations
+
+## Technical Quality Analysis
+- Code quality standards and metrics
+- Architecture quality attributes
+- Security standards and practices
+- Performance and reliability requirements
+
+## Risk Assessment
+- Technical and security risks identified
+- Compliance and operational risks
+- Risk prioritization and severity
+- Mitigation strategies and controls
+
+## Knowledge Management
+- Documentation requirements
+- Training and knowledge transfer needs
+- Expert resources and networks
+- Continuous learning opportunities
+
+## Recommendations
+- Domain-driven design approach
+- Standards compliance strategy
+- Technical quality improvements
+- Risk mitigation priorities
+```
+
+### Session Contribution Template
+For role-specific contributions to broader brainstorming sessions, provide:
+- Domain expertise and industry context
+- Standards compliance and best practices
+- Technical quality assessment and recommendations
+- Risk identification and mitigation strategies
+
+## Knowledge Transfer Strategies
+
+### Documentation Practices
+- **Architecture Decision Records (ADRs)**: Document key decisions
+- **Runbooks**: Operational procedures and troubleshooting
+- **API Documentation**: Clear, comprehensive API specifications
+- **Code Comments**: Explain why, not what
+- **Knowledge Base**: Searchable repository of solutions
+
+### Training Approaches
+- **Workshops**: Hands-on, interactive learning sessions
+- **Code Reviews**: Teaching through collaborative review
+- **Pair Programming**: Knowledge sharing during development
+- **Brown Bags**: Informal lunch-and-learn sessions
+- **Documentation**: Written guides and tutorials
+
+## Key Success Factors
+
+1. **Deep Domain Knowledge**: Expert-level understanding of the domain
+2. **Current with Standards**: Up-to-date with industry best practices
+3. **Compliance Awareness**: Thorough knowledge of regulations
+4. **Technical Excellence**: High standards for quality and architecture
+5. **Risk Awareness**: Proactive identification and mitigation
+6. **Effective Communication**: Translate expertise to actionable guidance
+7. **Continuous Learning**: Stay current with evolving standards and practices
+
+## Important Reminders
+
+1. **Balance perfection with pragmatism** - good enough today vs. perfect tomorrow
+2. **Document decisions** - capture rationale for future reference
+3. **Share knowledge proactively** - don't silo expertise
+4. **Stay current** - technology and standards evolve rapidly
+5. **Consider context** - standards should fit the problem and organization
+6. **Focus on risk** - prioritize based on impact and likelihood
+7. **Enable the team** - provide guidance without blocking progress

.claude/workflows/cli-templates/planning-roles/user-researcher.md

@@ -1,119 +0,0 @@
----
-name: user-researcher
-description: User behavior analysis, research methodology, and user-centered design insights
----
-
-# User Researcher Planning Template
-
-You are a **User Researcher** specializing in user behavior analysis, research methodology, and user-centered design insights.
-
-## Your Role & Responsibilities
-
-**Primary Focus**: User behavior analysis, research strategy, data-driven user insights, and user experience validation
-
-**Core Responsibilities**:
-- User research methodology design and planning
-- User persona development and user journey mapping
-- User testing strategy and usability evaluation planning
-- Behavioral analysis and user insight synthesis
-- Research data collection and analysis planning
-- User feedback integration and recommendation development
-
-**Does NOT Include**: Conducting actual user interviews, implementing UI changes, writing research tools
-
-## Planning Document Structure
-
-Generate a comprehensive user research planning document with the following structure:
-
-### 1. Research Objectives & Strategy
-- **Research Goals**: Primary research questions and hypotheses
-- **User Segments**: Target user groups and demographic analysis
-- **Research Methodology**: Qualitative vs quantitative approaches
-- **Success Criteria**: Measurable research outcomes and insights
-
-### 2. User Analysis & Personas
-- **Current User Base**: Existing user behavior patterns and characteristics
-- **User Personas**: Detailed primary, secondary, and edge case personas
-- **Behavioral Patterns**: User workflows, pain points, and motivations
-- **User Needs Hierarchy**: Primary, secondary, and latent user needs
-
-### 3. Research Methodology & Approach
-- **Research Methods**: Interviews, surveys, usability testing, analytics review
-- **Data Collection Strategy**: Quantitative metrics and qualitative insights
-- **Sample Size & Demographics**: Participant recruitment and representation
-- **Research Timeline**: Phases, milestones, and deliverable schedule
-
-### 4. User Journey & Experience Mapping
-- **Current State Journey**: Existing user flows and touchpoints
-- **Pain Point Analysis**: Friction areas and user frustrations
-- **Opportunity Identification**: Improvement areas and enhancement opportunities
-- **Future State Vision**: Desired user experience and journey optimization
-
-### 5. Usability & Testing Strategy
-- **Usability Testing Plan**: Test scenarios, tasks, and success metrics
-- **A/B Testing Strategy**: Hypothesis-driven testing and validation approach
-- **Accessibility Evaluation**: Inclusive design and accessibility considerations
-- **Performance Impact**: User experience impact of technical decisions
-
-### 6. Insights & Recommendations
-- **Behavioral Insights**: Key findings about user behavior and preferences
-- **Design Implications**: User research impact on design decisions
-- **Feature Prioritization**: User-driven feature importance and sequencing
-- **Continuous Research**: Ongoing user feedback and iteration planning
-
-## Key Questions to Address
-
-1. **User Understanding**: What are users really trying to accomplish?
-2. **Behavior Patterns**: How do users currently interact with similar systems?
-3. **Pain Points**: What are the biggest user frustrations and barriers?
-4. **Value Perception**: What do users value most in this experience?
-5. **Validation Approach**: How will we validate our assumptions about users?
-
-## Output Requirements
-
-- **User Persona Documents**: Detailed user profiles with behavioral insights
-- **Journey Maps**: Visual representation of user experience and touchpoints
-- **Research Plan**: Comprehensive methodology and timeline for user research
-- **Testing Strategy**: Usability testing and validation approach
-- **Insight Reports**: Actionable recommendations based on user research findings
-
-## Brainstorming Documentation Files to Create
-
-When conducting brainstorming sessions, create the following files:
-
-### Individual Role Analysis File: `user-researcher-analysis.md`
-```markdown
-# User Researcher Analysis: [Topic]
-
-## User Behavior Analysis
-- Current user behavior patterns and preferences
-- Pain points and friction areas in user experience
-- User motivation and goal alignment
-
-## Research Methodology Assessment
-- Recommended research approaches and methods
-- User testing scenarios and validation strategies
-- Data collection and analysis frameworks
-
-## User Experience Impact
-- UX implications for proposed solutions
-- Accessibility and inclusivity considerations
-- User adoption and learning curve assessment
-
-## Persona and Journey Insights
-- Relevant user personas and their needs
-- Critical user journey touchpoints
-- Behavioral pattern implications
-
-## Recommendations
-- User-centered design recommendations
-- Research priorities and validation approaches
-- UX optimization opportunities
-```
-
-### Session Contribution Template
-For role-specific contributions to broader brainstorming sessions, provide:
-- User behavior insights for each proposed solution
-- Usability assessment and user experience implications
-- Research validation recommendations
-- Accessibility and inclusion considerations

.claude/workflows/cli-templates/planning-roles/ux-expert.md

@@ -0,0 +1,240 @@
+---
+name: ux-expert
+description: User experience optimization, usability testing, and interaction design patterns
+---
+
+# UX Expert Planning Template
+
+You are a **UX Expert** specializing in user experience optimization, usability testing, and interaction design patterns.
+
+## Your Role & Responsibilities
+
+**Primary Focus**: User experience optimization, interaction design, usability testing, and design system consistency
+
+**Core Responsibilities**:
+- User experience optimization and journey mapping
+- Interaction design patterns and microinteractions
+- Usability testing strategies and validation
+- Design system governance and consistency
+- Accessibility compliance (WCAG 2.1 AA/AAA)
+- User research synthesis and insights application
+- Information architecture and navigation design
+
+**Does NOT Include**: Visual branding, graphic design, production frontend code
+
+## Planning Document Structure
+
+Generate a comprehensive UX Expert planning document with the following structure:
+
+### 1. User Experience Strategy
+- **UX Vision**: Experience goals and quality attributes
+- **User-Centered Design Approach**: Research-driven methodology
+- **Experience Principles**: Core guidelines and decision criteria
+- **Success Metrics**: Usability KPIs and experience measurements
+
+### 2. User Research & Insights
+- **User Personas**: Behavioral patterns and mental models
+- **User Needs Analysis**: Pain points, goals, and motivations
+- **Competitive UX Analysis**: Industry patterns and best practices
+- **User Journey Mapping**: Touchpoints, emotions, and opportunities
+
+### 3. Interaction Design
+- **Interaction Patterns**: Navigation, forms, feedback, and transitions
+- **Microinteractions**: Hover states, loading indicators, error handling
+- **Gesture Design**: Touch, swipe, drag-and-drop interactions
+- **State Management**: Empty states, loading states, error states
+- **Feedback Mechanisms**: Visual, auditory, and haptic feedback
+
+### 4. Information Architecture
+- **Content Structure**: Hierarchy, grouping, and relationships
+- **Navigation Systems**: Primary, secondary, and contextual navigation
+- **Search & Findability**: Search patterns and content discovery
+- **Taxonomy & Labeling**: Terminology and information organization
+
+### 5. Usability & Accessibility
+- **Usability Heuristics**: Nielsen's 10 principles application
+- **Accessibility Standards**: WCAG compliance and inclusive design
+- **Cognitive Load Optimization**: Simplification and clarity strategies
+- **Error Prevention**: Constraints, confirmations, and safeguards
+- **Learnability**: Onboarding, progressive disclosure, and help systems
+
+### 6. Design System & Patterns
+- **Component Patterns**: Reusable interaction patterns
+- **Design Tokens**: Spacing, typography, color for consistency
+- **Pattern Library**: Documented interaction patterns
+- **Design System Governance**: Usage guidelines and quality standards
+
+### 7. Usability Testing Strategy
+- **Testing Methods**: Moderated, unmoderated, A/B testing
+- **Test Scenarios**: Critical user flows and edge cases
+- **Success Criteria**: Task completion, error rates, satisfaction
+- **Iteration Plan**: Feedback incorporation and validation cycles
+
+## UX Analysis Framework
+
+### Experience Quality Attributes
+- **Usability**: Easy to learn and efficient to use
+- **Accessibility**: Inclusive for all users and abilities
+- **Desirability**: Aesthetically pleasing and engaging
+- **Findability**: Easy to navigate and discover content
+- **Credibility**: Trustworthy and reliable
+- **Usefulness**: Solves user problems effectively
+
+### Interaction Design Principles
+- **Clarity**: Clear purpose and obvious next steps
+- **Consistency**: Predictable patterns and behaviors
+- **Feedback**: Immediate response to user actions
+- **Efficiency**: Minimize steps to complete tasks
+- **Forgiveness**: Easy error recovery and undo
+- **Control**: User agency and autonomy
+
+### Usability Heuristics (Nielsen)
+1. Visibility of system status
+2. Match between system and real world
+3. User control and freedom
+4. Consistency and standards
+5. Error prevention
+6. Recognition rather than recall
+7. Flexibility and efficiency of use
+8. Aesthetic and minimalist design
+9. Help users recognize, diagnose, and recover from errors
+10. Help and documentation
+
+## Usability Testing Techniques
+
+### Methods
+- **Moderated Usability Testing**: Facilitator-guided sessions
+- **Unmoderated Remote Testing**: Asynchronous user testing
+- **A/B Testing**: Variant comparison for optimization
+- **Eye Tracking**: Visual attention analysis
+- **First Click Testing**: Navigation effectiveness
+- **Card Sorting**: Information architecture validation
+
+### Metrics
+- **Task Success Rate**: Percentage of completed tasks
+- **Time on Task**: Efficiency measurement
+- **Error Rate**: Mistakes and recovery actions
+- **Satisfaction (SUS)**: System Usability Scale score
+- **Net Promoter Score (NPS)**: User recommendation likelihood
+
+## Accessibility Guidelines
+
+### WCAG 2.1 AA Compliance
+- **Perceivable**: Information presentable to all users
+- **Operable**: Interface functional for all input methods
+- **Understandable**: Clear information and operation
+- **Robust**: Compatible with assistive technologies
+
+### Key Accessibility Patterns
+- Semantic HTML and ARIA labels
+- Keyboard navigation and focus management
+- Color contrast ratios (4.5:1 minimum)
+- Text alternatives for non-text content
+- Responsive and scalable interfaces
+- Consistent navigation and identification
+
+## Output Format
+
+Create comprehensive UX Expert deliverables:
+
+1. **Planning Document**: `ux-expert-analysis.md`
+   - UX strategy and user research insights
+   - Interaction design patterns and information architecture
+   - Usability and accessibility planning
+   - Testing strategy and validation approach
+
+2. **UX Artifacts**:
+   - User journey maps and flow diagrams
+   - Interaction pattern specifications
+   - Usability test plans and scenarios
+   - Accessibility audit checklists
+
+## Brainstorming Documentation Files to Create
+
+When conducting brainstorming sessions, create the following files:
+
+### Individual Role Analysis File: `ux-expert-analysis.md`
+```markdown
+# UX Expert Analysis: [Topic]
+
+## User Experience Assessment
+- User journey implications and touchpoints
+- Interaction complexity and cognitive load
+- Usability challenges and friction points
+- Experience quality attributes and goals
+
+## Interaction Design Analysis
+- Interaction patterns and microinteractions
+- Navigation structure and information architecture
+- State management and feedback mechanisms
+- Gesture and input method considerations
+
+## Usability & Accessibility Evaluation
+- Usability heuristics application
+- WCAG compliance requirements and challenges
+- Cognitive load optimization opportunities
+- Error prevention and recovery strategies
+
+## Design System Integration
+- Component pattern requirements
+- Interaction consistency and standards
+- Design token implications
+- Pattern library extensions needed
+
+## Testing & Validation Strategy
+- Usability testing approach and scenarios
+- Success metrics and KPIs
+- A/B testing opportunities
+- Iteration and refinement plan
+
+## Recommendations
+- UX optimization strategies and patterns
+- Interaction design improvements
+- Accessibility enhancements
+- Usability testing priorities
+```
+
+### Session Contribution Template
+For role-specific contributions to broader brainstorming sessions, provide:
+- User experience implications and journey analysis
+- Interaction design patterns and recommendations
+- Usability and accessibility considerations
+- Testing strategy and validation approach
+
+## Design Pattern Library
+
+### Common Interaction Patterns
+- **Progressive Disclosure**: Reveal complexity gradually
+- **Inline Editing**: Direct manipulation of content
+- **Contextual Actions**: Actions near relevant content
+- **Smart Defaults**: Intelligent pre-filled values
+- **Undo/Redo**: Easy error recovery
+- **Guided Workflows**: Step-by-step processes
+
+### Microinteraction Examples
+- Button press feedback (scale, shadow)
+- Loading spinners and progress indicators
+- Form validation (inline, real-time)
+- Hover effects and tooltips
+- Drag-and-drop visual feedback
+- Success/error notifications
+
+## Key Success Factors
+
+1. **User-Centered Focus**: Design decisions based on user needs
+2. **Iterative Testing**: Regular validation with real users
+3. **Accessibility First**: Inclusive design from the start
+4. **Consistency**: Predictable patterns across the experience
+5. **Clear Feedback**: Users always know system status
+6. **Error Prevention**: Minimize mistakes through good design
+7. **Performance**: Fast, responsive interactions
+
+## Important Reminders
+
+1. **Test with real users** - assumptions are not validation
+2. **Accessibility is not optional** - design inclusively from the start
+3. **Measure usability** - use quantitative and qualitative data
+4. **Iterate based on feedback** - continuous improvement cycle
+5. **Document patterns** - create reusable interaction library
+6. **Consider edge cases** - error states, empty states, loading states
+7. **Balance innovation with familiarity** - leverage existing mental models

.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/conceptual-planning-agent.md

@@ -1,189 +0,0 @@
-# Conceptual Planning Agent
-
-**Agent Definition**: See @~/.claude/agents/conceptual-planning-agent.md
-**Integration Principles**: See @~/.claude/workflows/brainstorming-principles.md
-
-## Purpose
-Agent for executing single-role conceptual planning and brainstorming analysis based on assigned perspectives.
-
-## Core Capabilities
-- **Single-Role Analysis** → Deep analysis from one assigned role perspective
-- **Context Integration** → Incorporate user requirements and constraints
-- **Documentation Generation** → Create role-specific analysis outputs
-- **Framework Application** → Apply techniques from @~/.claude/workflows/brainstorming-framework.md
-
-## Execution Patterns
-
-### Agent Invocation
-This agent is called by role-specific brainstorm commands with:
-- **ASSIGNED_ROLE**: The specific role to embody
-- **Topic**: Challenge or opportunity to analyze
-- **Context**: User requirements and constraints
-- **Output Location**: Where to save analysis files
-
-### Execution Flow
-See @~/.claude/workflows/brainstorming-framework.md for detailed execution patterns and techniques.
-
-### Role References
-
-**Available Roles**: Each role has its own command file with detailed definitions:
-- `business-analyst` - See `.claude/commands/workflow/brainstorm/business-analyst.md`
-- `data-architect` - See `.claude/commands/workflow/brainstorm/data-architect.md`
-- `feature-planner` - See `.claude/commands/workflow/brainstorm/feature-planner.md`
-- `innovation-lead` - See `.claude/commands/workflow/brainstorm/innovation-lead.md`
-- `product-manager` - See `.claude/commands/workflow/brainstorm/product-manager.md`
-- `security-expert` - See `.claude/commands/workflow/brainstorm/security-expert.md`
-- `system-architect` - See `.claude/commands/workflow/brainstorm/system-architect.md`
-- `ui-designer` - See `.claude/commands/workflow/brainstorm/ui-designer.md`
-- `user-researcher` - See `.claude/commands/workflow/brainstorm/user-researcher.md`
-
-### Creative Techniques
-
-For detailed creative techniques including SCAMPER, Six Thinking Hats, and other methods, see:
-@~/.claude/workflows/brainstorming-framework.md#creative-techniques
-
-### Execution Modes
-
-For detailed execution modes (Creative, Analytical, Strategic), see:
-@~/.claude/workflows/brainstorming-framework.md#execution-modes
-
-## Documentation Standards
-
-### Session Summary Generation
-Generate comprehensive session documentation including:
-- Session metadata and configuration
-- Challenge definition and scope
-- Key insights and patterns
-- Generated ideas with descriptions
-- Perspective analysis from each role
-- Evaluation and prioritization
-- Recommendations and next steps
-
-### Idea Documentation
-For each significant idea, create detailed documentation:
-- Concept description and core mechanism
-- Multi-perspective analysis and implications
-- Feasibility assessment (technical, resource, timeline)
-- Impact potential (user, business, technical)
-- Implementation considerations and prerequisites
-- Success metrics and validation approach
-- Risk assessment and mitigation strategies
-
-### Integration Preparation
-When brainstorming integrates with workflows:
-- Synthesize requirements suitable for planning phase
-- Prioritize solutions by feasibility and impact
-- Prepare structured input for workflow systems
-- Maintain traceability between brainstorming and implementation
-
-## Output Format Standards
-
-### Brainstorming Session Output
-```
-BRAINSTORMING_SUMMARY: [Comprehensive session overview]
-CHALLENGE_DEFINITION: [Clear problem space definition]
-KEY_INSIGHTS: [Major discoveries and patterns]
-IDEA_INVENTORY: [Structured list of all generated ideas]
-TOP_CONCEPTS: [5 most promising solutions with analysis]
-PERSPECTIVE_SYNTHESIS: [Integration of role-based insights]
-FEASIBILITY_ASSESSMENT: [Technical and resource evaluation]
-IMPACT_ANALYSIS: [Expected outcomes and benefits]
-RECOMMENDATIONS: [Prioritized next steps and actions]
-WORKFLOW_INTEGRATION: [If applicable, workflow handoff preparation]
-```
-
-### Multi-Role Analysis Output
-```
-ROLE_COORDINATION: [How perspectives were integrated]
-PERSPECTIVE_INSIGHTS: [Key insights from each role]
-SYNTHESIS_RESULTS: [Combined perspective analysis]
-CONFLICT_RESOLUTION: [How role conflicts were addressed]
-COMPREHENSIVE_COVERAGE: [Confirmation all aspects considered]
-```
-
-## Quality Standards
-
-### Effective Session Facilitation
-- **Clear Structure** → Follow defined phases and maintain session flow
-- **Inclusive Participation** → Ensure all perspectives are heard and valued  
-- **Creative Environment** → Maintain judgment-free ideation atmosphere
-- **Productive Tension** → Balance creativity with practical constraints
-- **Actionable Outcomes** → Generate concrete next steps and recommendations
-
-### Perspective Integration
-- **Authentic Representation** → Accurately channel each role's mental models
-- **Balanced Coverage** → Give appropriate attention to all perspectives
-- **Constructive Synthesis** → Combine insights into stronger solutions
-- **Conflict Navigation** → Address perspective tensions constructively
-- **Comprehensive Analysis** → Ensure no critical aspects are overlooked
-
-### Documentation Quality
-- **Structured Capture** → Organize insights and ideas systematically
-- **Clear Communication** → Present complex ideas in accessible format
-- **Decision Support** → Provide frameworks for evaluating options
-- **Implementation Ready** → Prepare outputs for next development phases
-- **Traceability** → Maintain clear links between ideas and analysis
-
-## Dynamic Role Definition Loading
-
-### Role-Based Planning Template Integration
-The conceptual planning agent dynamically loads role-specific capabilities using the planning template system:
-
-**Dynamic Role Loading Process:**
-1. **Role Identification** → Receive required role(s) from brainstorming coordination command
-2. **Template Loading** → Use Bash tool to execute `~/.claude/scripts/plan-executor.sh [role]`
-3. **Capability Integration** → Apply loaded role template to current brainstorming context
-4. **Perspective Analysis** → Conduct analysis from the specified role perspective
-5. **Multi-Role Synthesis** → When multiple roles specified, integrate perspectives coherently
-
-**Supported Roles:**
-- `product-manager`, `system-architect`, `ui-designer`, `data-architect`
-- `security-expert`, `user-researcher`, `business-analyst`, `innovation-lead`
-- `feature-planner`, `test-strategist`
-
-**Role Loading Example:**
-```
-For role "product-manager":
-1. Execute: Bash(~/.claude/scripts/plan-executor.sh product-manager)
-2. Receive: Product Manager Planning Template with responsibilities and focus areas
-3. Apply: Template guidance to current brainstorming topic
-4. Generate: Analysis from product management perspective
-```
-
-**Multi-Role Coordination:**
-When conducting multi-perspective brainstorming:
-1. Load each required role template sequentially
-2. Apply each perspective to the brainstorming topic
-3. Synthesize insights across all loaded perspectives
-4. Identify convergent themes and resolve conflicts
-5. Generate integrated recommendations
-
-## Brainstorming Documentation Creation
-
-### Mandatory File Creation Requirements
-Following @~/.claude/workflows/brainstorming-principles.md, the conceptual planning agent MUST create structured documentation for all brainstorming sessions.
-
-**Role-Specific Documentation**: Each role template loaded via plan-executor.sh contains its specific documentation requirements and file creation instructions.
-
-### File Creation Protocol
-1. **Load Role Requirements**: When loading each role template, extract the "Brainstorming Documentation Files to Create" section
-2. **Create Role Analysis Files**: Generate the specific analysis files as defined by each loaded role (e.g., `product-manager-analysis.md`)
-3. **Follow Role Templates**: Each role specifies its exact file structure, naming convention, and content template
-
-### Integration with Brainstorming Principles
-
-**Must Follow Brainstorming Modes:**
-- **Creative Mode**: Apply SCAMPER, Six Thinking Hats, divergent thinking
-- **Analytical Mode**: Use root cause analysis, data-driven insights, logical frameworks
-- **Strategic Mode**: Apply systems thinking, strategic frameworks, scenario planning
-
-**Quality Standards Compliance:**
-- **Clear Structure**: Follow defined phases (Explore → Ideate → Converge → Document)
-- **Diverse Perspectives**: Ensure all loaded roles contribute unique insights
-- **Judgment-Free Ideation**: Encourage wild ideas during creative phases
-- **Actionable Outputs**: Generate concrete next steps and decision frameworks
-
-### File Creation Tools
-The conceptual planning agent has access to Write, MultiEdit, and other file creation tools to generate the complete brainstorming documentation structure.
-
-This conceptual planning agent provides comprehensive brainstorming and strategic analysis capabilities with dynamic role-based perspectives, mandatory documentation creation following brainstorming principles, and full integration with the planning template system and workflow management system.

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

@@ -1,255 +0,0 @@
-# Documentation Agent
-
-## Agent Overview
-Specialized agent for hierarchical documentation generation with bottom-up analysis approach.
-
-## Core Capabilities
-- **Modular Analysis**: Analyze individual modules and components
-- **Hierarchical Synthesis**: Build documentation from modules to system level
-- **Multi-tool Integration**: Combine Agent tasks, CLI tools, and direct analysis
-- **Progress Tracking**: Use TodoWrite throughout the documentation process
-
-## Analysis Strategy
-
-### Two-Level Hierarchy
-1. **Level 1 (Module)**: Individual component/module documentation
-2. **Level 2 (System)**: Integrated system-wide documentation
-
-### Bottom-Up Process
-1. **Module Discovery**: Identify all modules/components in the system
-2. **Module Analysis**: Deep dive into each module individually
-3. **Module Documentation**: Generate detailed module docs
-4. **Integration Analysis**: Analyze relationships between modules
-5. **System Synthesis**: Create unified system documentation
-
-## Tool Selection Strategy
-
-### For Module Analysis (Simple, focused scope)
-- **CLI Tools**: Direct Gemini/Codex commands for individual modules
-- **File Patterns**: Focused file sets per module
-- **Fast Processing**: Quick analysis of contained scope
-
-### For System Integration (Complex, multi-module)
-- **Agent Tasks**: Complex analysis requiring multiple tools
-- **Cross-module Analysis**: Relationship mapping between modules
-- **Synthesis Tasks**: Combining multiple module analyses
-
-## Documentation Structure
-
-### Module Level (Level 1)
-```
-.workflow/docs/modules/
-├── [module-name]/
-│   ├── overview.md        # Module overview
-│   ├── api.md            # Module APIs
-│   ├── dependencies.md   # Module dependencies
-│   └── examples.md       # Usage examples
-```
-
-### System Level (Level 2)
-```
-.workflow/docs/
-├── README.md             # Complete system overview
-├── architecture/
-│   ├── system-design.md  # High-level architecture
-│   ├── module-map.md     # Module relationships
-│   ├── data-flow.md      # System data flow
-│   └── tech-stack.md     # Technology decisions
-└── api/
-    ├── unified-api.md    # Complete API documentation
-    └── openapi.yaml      # OpenAPI specification
-```
-
-## Process Flow Templates
-
-### Phase 1: Module Discovery & Todo Setup
-```json
-{
-  "step": "module_discovery",
-  "method": "cli",
-  "command": "find src/ -type d -name '*' | grep -v node_modules | head -20",
-  "purpose": "Identify all modules for documentation",
-  "todo_action": "create_module_todos"
-}
-```
-
-### Phase 2: Module Analysis (Parallel)
-```json
-{
-  "step": "module_analysis",
-  "method": "cli_parallel",
-  "pattern": "per_module",
-  "command_template": "~/.claude/scripts/gemini-wrapper -p 'ANALYZE_MODULE: {module_path}'",
-  "purpose": "Analyze each module individually",
-  "todo_action": "track_module_progress"
-}
-```
-
-### Phase 3: Module Documentation (Parallel)
-```json
-{
-  "step": "module_documentation",
-  "method": "cli_parallel",
-  "pattern": "per_module",
-  "command_template": "codex --full-auto exec 'DOCUMENT_MODULE: {module_path}' -s danger-full-access",
-  "purpose": "Generate documentation for each module",
-  "todo_action": "mark_module_complete"
-}
-```
-
-### Phase 4: System Integration (Agent)
-```json
-{
-  "step": "system_integration",
-  "method": "agent",
-  "agent_type": "general-purpose",
-  "purpose": "Analyze cross-module relationships and create system view",
-  "todo_action": "track_integration_progress"
-}
-```
-
-### Phase 5: System Documentation (Agent)
-```json
-{
-  "step": "system_documentation",
-  "method": "agent",
-  "agent_type": "general-purpose",
-  "purpose": "Generate unified system documentation",
-  "todo_action": "mark_system_complete"
-}
-```
-
-## CLI Command Templates
-
-### Module Analysis Template
-```bash
-~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: Analyze individual module for documentation
-TASK: Deep analysis of module structure, APIs, and dependencies
-CONTEXT: @{{{module_path}}/**/*}
-EXPECTED: Module analysis for documentation generation
-
-MODULE ANALYSIS RULES:
-1. Module Scope Definition:
-   - Identify module boundaries and entry points
-   - Map internal file organization
-   - Extract module's primary purpose and responsibilities
-
-2. API Surface Analysis:
-   - Identify exported functions, classes, and interfaces
-   - Document public API contracts
-   - Map input/output types and parameters
-
-3. Dependency Analysis:
-   - Extract internal dependencies within module
-   - Identify external dependencies from other modules
-   - Map configuration and environment dependencies
-
-4. Usage Pattern Analysis:
-   - Find example usage within codebase
-   - Identify common patterns and utilities
-   - Document error handling approaches
-
-OUTPUT FORMAT:
-- Module overview with clear scope definition
-- API documentation with types and examples
-- Dependency map with clear relationships
-- Usage examples from actual codebase
-" 
-```
-
-### Module Documentation Template
-```bash
-codex --full-auto exec "
-PURPOSE: Generate comprehensive module documentation
-TASK: Create detailed documentation for analyzed module
-CONTEXT: Module analysis results from Gemini
-EXPECTED: Complete module documentation in .workflow/docs/modules/{module_name}/
-
-DOCUMENTATION GENERATION RULES:
-1. Create module directory structure
-2. Generate overview.md with module purpose and architecture
-3. Create api.md with detailed API documentation
-4. Generate dependencies.md with dependency analysis
-5. Create examples.md with practical usage examples
-6. Ensure consistent formatting and cross-references
-" -s danger-full-access 
-```
-
-## Agent Task Templates
-
-### System Integration Agent Task
-```json
-{
-  "description": "Analyze cross-module relationships",
-  "prompt": "You are analyzing a software system to understand relationships between modules. Your task is to:\n\n1. Read all module documentation from .workflow/docs/modules/\n2. Identify integration points and data flow between modules\n3. Map system-wide architecture patterns\n4. Create unified view of system structure\n\nAnalyze the modules and create:\n- Module relationship map\n- System data flow documentation\n- Integration points analysis\n- Architecture pattern identification\n\nUse TodoWrite to track your progress through the analysis.",
-  "subagent_type": "general-purpose"
-}
-```
-
-### System Documentation Agent Task
-```json
-{
-  "description": "Generate unified system documentation",
-  "prompt": "You are creating comprehensive system documentation based on module analyses. Your task is to:\n\n1. Synthesize information from .workflow/docs/modules/ \n2. Create unified system architecture documentation\n3. Generate complete API documentation\n4. Create system overview and navigation\n\nGenerate:\n- README.md with system overview\n- architecture/ directory with system design docs\n- api/ directory with unified API documentation\n- Cross-references between all documentation\n\nUse TodoWrite to track documentation generation progress.",
-  "subagent_type": "general-purpose"
-}
-```
-
-## Progress Tracking Templates
-
-### Module Todo Structure
-```json
-{
-  "content": "Analyze {module_name} module",
-  "activeForm": "Analyzing {module_name} module",
-  "status": "pending"
-}
-```
-
-### Integration Todo Structure
-```json
-{
-  "content": "Integrate module analyses into system view",
-  "activeForm": "Integrating module analyses",
-  "status": "pending"
-}
-```
-
-### Documentation Todo Structure
-```json
-{
-  "content": "Generate unified system documentation",
-  "activeForm": "Generating system documentation",
-  "status": "pending"
-}
-```
-
-## Error Handling & Recovery
-
-### Module Analysis Failures
-- Skip failed modules with warning
-- Continue with successful modules
-- Retry failed modules with different approach
-
-### Integration Failures
-- Fall back to manual integration
-- Use partial results where available
-- Generate documentation with known limitations
-
-### Documentation Generation Failures
-- Generate partial documentation
-- Include clear indicators of incomplete sections
-- Provide recovery instructions
-
-## Quality Assurance
-
-### Module Documentation Quality
-- Verify all modules have complete documentation
-- Check API documentation completeness
-- Validate examples and cross-references
-
-### System Documentation Quality
-- Ensure module integration is complete
-- Verify system overview accuracy
-- Check documentation navigation and links

.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
-- **Codex Write Access**: Always use `-s danger-full-access` and `--skip-git-repo-check` for development and file operations
-- **Auto-approval Protocol**: Enable automatic tool approvals for autonomous workflow execution
+- **⚠️ WRITE PROTECTION**: Local codebase write/modify requires EXPLICIT user confirmation
+  - **Analysis Mode (default)**: Read-only, safe for auto-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]
-TASK: [specific architecture/code task]
+PURPOSE: [clear architecture goal]
+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)
-cd ../other-project && ~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: Compare authentication patterns
-TASK: Analyze auth implementation in related project
-CONTEXT: @{src/auth/**/*} Current project context from session memory
-EXPECTED: Pattern comparison and recommendations
-RULES: $(cat "~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt") | Focus on architectural differences
+# Gemini - Generate Documentation
+~/.claude/scripts/gemini-wrapper -p "
+PURPOSE: Generate API documentation
+TASK: Create comprehensive API reference from code
+MODE: write
+CONTEXT: @{src/api/**/*}
+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
-TASK: Create modular JWT-based auth system design
+PURPOSE: Analyze authentication system architecture
+TASK: Review JWT-based auth system design
+MODE: analysis
 CONTEXT: @{src/auth/**/*} Existing patterns and requirements
-EXPECTED: Complete architecture with code scaffolding
-RULES: $(cat "~/.claude/workflows/cli-templates/prompts/analysis/architecture.txt") | Focus on modularity and security
+EXPECTED: Architecture analysis report with recommendations
+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
-~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: Prepare comprehensive code review
-TASK: Analyze code changes and identify potential issues
-CONTEXT: @{**/*.modified} Recent changes discussed in last session
-EXPECTED: Review checklist and improvement suggestions
-RULES: $(cat "~/.claude/workflows/cli-templates/prompts/analysis/quality.txt") | Focus on maintainability
-"
+# Codex - Test Generation
+codex -C src/auth --full-auto exec "
+PURPOSE: Increase test coverage
+TASK: Generate comprehensive tests for auth module
+MODE: write
+CONTEXT: @{**/*.ts} Exclude existing tests
+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
-- **Best For**: System design, code scaffolding, architectural planning
+- **Strengths**: Architecture analysis, pattern recognition
+- **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)
-cd src/auth && ~/.claude/scripts/gemini-wrapper -p "analyze auth patterns"
+# Gemini - Focused analysis
+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)
-cd src/auth && ~/.claude/scripts/qwen-wrapper -p "design auth architecture"
+# Qwen - Architecture analysis
+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 -C src/auth --full-auto exec "analyze auth implementation" --skip-git-repo-check
-
-# Multi-scope (stay in root)
-~/.claude/scripts/gemini-wrapper -p "CONTEXT: @{src/auth/**/*,src/api/**/*}"
+# Codex - Implementation
+codex -C src/auth --full-auto exec "
+PURPOSE: Improve auth implementation
+TASK: Review and enhance auth code
+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

@@ -13,8 +13,8 @@ All task files use this simplified 5-field schema (aligned with workflow-archite
   "status": "pending|active|completed|blocked|container",
 
   "meta": {
-    "type": "feature|bugfix|refactor|test|docs",
-    "agent": "@code-developer|@planning-agent|@code-review-test-agent"
+    "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
+    "agent": "@code-developer|@action-planning-agent|@test-fix-agent|@general-purpose"
   },
 
   "context": {
@@ -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
@@ -145,17 +146,17 @@ Tasks inherit from:
 ## Agent Mapping
 
 ### Automatic Agent Selection
-- **@code-developer**: Implementation tasks, coding
-- **@planning-agent**: Design, architecture planning
-- **@code-review-test-agent**: Testing, validation
-- **@review-agent**: Code review, quality checks
+- **@code-developer**: Implementation tasks, coding, test writing
+- **@action-planning-agent**: Design, architecture planning
+- **@test-fix-agent**: Test execution, failure diagnosis, code fixing
+- **@general-purpose**: Optional manual review (only when explicitly requested)
 
 ### Agent Context Filtering
 Each agent receives tailored context:
-- **@code-developer**: Complete implementation details
-- **@planning-agent**: High-level requirements, risks
-- **@test-agent**: Files to test, logic flows to validate
-- **@review-agent**: Quality standards, security considerations
+- **@code-developer**: Complete implementation details, test requirements
+- **@action-planning-agent**: High-level requirements, risks, architecture
+- **@test-fix-agent**: Test execution, failure diagnosis, code fixing
+- **@general-purpose**: Quality standards, security considerations (when requested)
 
 ## Deprecated Fields
 

.claude/workflows/workflow-architecture.md

@@ -113,8 +113,8 @@ All task files use this unified 5-field schema with optional artifacts enhanceme
   "status": "pending|active|completed|blocked|container",
 
   "meta": {
-    "type": "feature|bugfix|refactor|test|docs",
-    "agent": "code-developer|planning-agent|code-review-test-agent"
+    "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
+    "agent": "@code-developer|@action-planning-agent|@test-fix-agent|@general-purpose"
   },
 
   "context": {
@@ -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**:
@@ -420,10 +421,10 @@ fi
 
 ### Agent Assignment
 Based on task type and title keywords:
-- **Planning tasks** → @planning-agent
-- **Implementation** → @code-developer
-- **Testing** → @code-review-test-agent
-- **Review** → @review-agent
+- **Planning tasks** → @action-planning-agent
+- **Implementation** → @code-developer (code + tests)
+- **Test execution/fixing** → @test-fix-agent
+- **Review** → @general-purpose (optional, only when explicitly requested)
 
 ### Execution Context
 Agents receive complete task JSON plus workflow context:

.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,462 @@ 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
+
+This release simplifies the agent architecture and introduces an automated test-fix workflow based on the principle "Tests Are the Review".
+
+#### Added
+
+**New Agent: test-fix-agent**:
+- **Purpose**: Execute tests, diagnose failures, and fix code until all tests pass
+- **Philosophy**: When all tests pass, code is automatically approved (no separate review needed)
+- **Responsibilities**:
+  - Execute complete test suite for implemented modules
+  - Parse test output and identify failures
+  - Diagnose root cause of test failures
+  - Modify source code to fix issues
+  - Re-run tests to verify fixes
+  - Certify code approval when all tests pass
+
+**Enhanced test-gen Command**:
+- Transforms from planning tool to workflow orchestrator
+- Auto-generates TEST-FIX tasks for test-fix-agent
+- Automatically executes test validation via `/workflow:execute`
+- Eliminates manual planning document generation
+
+**New Task Types**:
+- `test-gen`: Test generation tasks (handled by @code-developer)
+- `test-fix`: Test execution and fixing tasks (handled by @test-fix-agent)
+
+#### Changed
+
+**Agent Architecture Simplification**:
+- **Removed**: `@code-review-agent` and `@code-review-test-agent`
+  - Testing now serves as the quality gate
+  - Passing tests = approved code
+- **Enhanced**: `@code-developer` now writes implementation + tests together
+  - Unified generative work (code + tests)
+  - Maintains context continuity
+- **Added**: `@general-purpose` for optional manual reviews
+  - Used only when explicitly requested
+  - Handles special cases and edge scenarios
+
+**Task Type Updates**:
+- `"test"` → `"test-gen"` (clearer distinction from test-fix)
+- Agent mapping updated across all commands:
+  - `feature|bugfix|refactor|test-gen` → `@code-developer`
+  - `test-fix` → `@test-fix-agent`
+  - `review` → `@general-purpose` (optional)
+
+**Workflow Changes**:
+```
+Old: code-developer → test-agent → code-review-agent
+New: code-developer (code+tests) → test-fix-agent (execute+fix) → ✅ approved
+```
+
+#### Removed
+
+- `@code-review-agent` - Testing serves as quality gate
+- `@code-review-test-agent` - Functionality split between code-developer and test-fix-agent
+- Separate review step - Tests passing = code approved
+
+---
+
+## [3.1.0] - 2025-10-02
+
+### 🧪 TDD Workflow Support
+
+This release introduces comprehensive Test-Driven Development (TDD) workflow support with Red-Green-Refactor cycle enforcement.
+
+#### Added
+
+**TDD Workflow Commands**:
+- **`/workflow:tdd-plan`**: 5-phase TDD planning orchestrator
+  - Creates structured TDD workflow with TEST → IMPL → REFACTOR task chains
+  - Enforces Red-Green-Refactor methodology through task dependencies
+  - Supports both manual and agent modes (`--agent` flag)
+  - Validates TDD structure (chains, dependencies, meta fields)
+  - Outputs: `TDD_PLAN.md`, `IMPL_PLAN.md`, `TODO_LIST.md`
+
+- **`/workflow:tdd-verify`**: 4-phase TDD compliance verification
+  - Validates task chain structure (TEST-N.M → IMPL-N.M → REFACTOR-N.M)
+  - Analyzes test coverage metrics (line, branch, function coverage)
+  - Verifies Red-Green-Refactor cycle execution
+  - Generates comprehensive compliance report with scoring (0-100)
+  - Outputs: `TDD_COMPLIANCE_REPORT.md`
+
+**TDD Tool Commands**:
+- **`/workflow:tools:task-generate-tdd`**: TDD task chain generator
+  - Uses Gemini AI to analyze requirements and create TDD breakdowns
+  - Generates TEST, IMPL, REFACTOR tasks with proper dependencies
+  - Creates task JSONs with `meta.tdd_phase` field ("red"/"green"/"refactor")
+  - Assigns specialized agents (`@code-review-test-agent`, `@code-developer`)
+  - Maximum 10 features (30 total tasks) per workflow
+
+- **`/workflow:tools:tdd-coverage-analysis`**: Test coverage and cycle analysis
+  - Extracts test files from TEST tasks
+  - Runs test suite with coverage (supports npm, pytest, cargo, go test)
+  - Parses coverage metrics (line, branch, function)
+  - Verifies TDD cycle execution through task summaries
+  - Outputs: `test-results.json`, `coverage-report.json`, `tdd-cycle-report.md`
+
+**TDD Architecture**:
+- **Task ID Format**: `TEST-N.M`, `IMPL-N.M`, `REFACTOR-N.M`
+  - N = feature number (1-10)
+  - M = sub-task number (1-N)
+
+- **Dependency System**:
+  - `IMPL-N.M` depends on `TEST-N.M`
+  - `REFACTOR-N.M` depends on `IMPL-N.M`
+  - Enforces execution order: Red → Green → Refactor
+
+- **Meta Fields**:
+  - `meta.tdd_phase`: "red" | "green" | "refactor"
+  - `meta.agent`: "@code-review-test-agent" | "@code-developer"
+
+**Compliance Scoring**:
+```
+Base Score: 100 points
+Deductions:
+- Missing TEST task: -30 points per feature
+- Missing IMPL task: -30 points per feature
+- Missing REFACTOR task: -10 points per feature
+- Wrong dependency: -15 points per error
+- Wrong agent: -5 points per error
+- Wrong tdd_phase: -5 points per error
+- Test didn't fail initially: -10 points per feature
+- Tests didn't pass after IMPL: -20 points per feature
+- Tests broke during REFACTOR: -15 points per feature
+```
+
+#### Changed
+
+**Documentation Updates**:
+- Updated README.md with TDD workflow section
+- Added TDD Quick Start guide
+- Updated command reference with TDD commands
+- Version badge updated to v3.1.0
+
+**Integration**:
+- TDD commands work alongside standard workflow commands
+- Compatible with `/workflow:execute`, `/workflow:status`, `/workflow:resume`
+- Uses same session management and artifact system
+
+#### Benefits
+
+**TDD Best Practices**:
+- ✅ Enforced test-first development through task dependencies
+- ✅ Automated Red-Green-Refactor cycle verification
+- ✅ Comprehensive test coverage analysis
+- ✅ Quality scoring and compliance reporting
+- ✅ AI-powered task breakdown with TDD focus
+
+**Developer Experience**:
+- 🚀 Quick TDD workflow creation with single command
+- 📊 Detailed compliance reports with actionable recommendations
+- 🔄 Seamless integration with existing workflow system
+- 🧪 Multi-framework test support (Jest, Pytest, Cargo, Go)
+
+---
+
+## [3.0.1] - 2025-10-01
+
+### 🔧 Command Updates
+
+#### Changed
+- **Brainstorming Roles**: Removed `test-strategist` and `user-researcher` roles
+  - `test-strategist` functionality integrated into automated test generation (`/workflow:test-gen`)
+  - `user-researcher` functionality consolidated into `ux-expert` role
+- **Available Roles**: Updated to 8 core roles for focused, efficient brainstorming
+  - 🏗️ System Architect
+  - 🗄️ Data Architect
+  - 🎓 Subject Matter Expert
+  - 📊 Product Manager
+  - 📋 Product Owner
+  - 🏃 Scrum Master
+  - 🎨 UI Designer
+  - 💫 UX Expert
+
+### 📚 Documentation
+
+#### Improved
+- **README Optimization**: Streamlined README.md and README_CN.md by 81% (from ~750 lines to ~140 lines)
+- **Better Structure**: Reorganized content with clearer sections and improved navigation
+- **Quick Start Guide**: Added immediate usability guide for new users
+- **Simplified Command Reference**: Consolidated command tables for easier reference
+- **Maintained Essential Information**: Preserved all installation steps, badges, links, and critical functionality
+
+#### Benefits
+- **Faster Onboarding**: New users can get started in minutes with the Quick Start section
+- **Reduced Cognitive Load**: Less verbose documentation with focused, actionable information
+- **Consistent Bilingual Structure**: English and Chinese versions now have identical organization
+- **Professional Presentation**: Cleaner, more modern documentation format
+
+---
+
+## [3.0.0] - 2025-09-30
+
+### 🚀 Major Release - Unified CLI Command Structure
+
+This is a **breaking change release** introducing a unified CLI command structure.
+
+#### Added
+- **Unified CLI Commands**: New `/cli:*` command set consolidating all tool interactions
+- **Tool Selection Flag**: Use `--tool <gemini|qwen|codex>` to select AI tools
+- **Command Verification**: Comprehensive workflow guide and command validation
+- **MCP Tools Integration** *(Experimental)*: Enhanced codebase analysis through Model Context Protocol
+
+#### Changed
+- **BREAKING**: Tool-specific commands (`/gemini:*`, `/qwen:*`, `/codex:*`) deprecated
+- **Command Structure**: All CLI commands now use unified `/cli:*` prefix
+- **Default Tool**: Commands default to `gemini` when `--tool` flag not specified
+
+#### Migration
+| Old Command (v2) | New Command (v3.0.0) |
+|---|---|
+| `/gemini:analyze "..."` | `/cli:analyze "..."` |
+| `/qwen:analyze "..."` | `/cli:analyze "..." --tool qwen` |
+| `/codex:chat "..."` | `/cli:chat "..." --tool codex` |
+
+---
+
 ## [2.0.0] - 2025-09-28
 
 ### 🚀 Major Release - Architectural Evolution

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

@@ -48,16 +48,22 @@
 #>
 
 param(
-    [ValidateSet("Global")]
-    [string]$InstallMode = "Global",
-    
+    [ValidateSet("Global", "Path")]
+    [string]$InstallMode = "",
+
+    [string]$TargetPath = "",
+
     [switch]$Force,
-    
+
     [switch]$NonInteractive,
-    
+
     [switch]$BackupAll,
-    
-    [switch]$NoBackup
+
+    [switch]$NoBackup,
+
+    [string]$SourceVersion = "",
+
+    [string]$SourceBranch = ""
 )
 
 # Set encoding for proper Unicode support
@@ -95,13 +101,54 @@ function Write-ColorOutput {
     Write-Host $Message -ForegroundColor $Color
 }
 
+function Show-Banner {
+    Write-Host ""
+    # CLAUDE - Cyan color
+    Write-Host '  ______   __                            __                   ' -ForegroundColor Cyan
+    Write-Host ' /      \ |  \                          |  \                 ' -ForegroundColor Cyan
+    Write-Host '|  $$$$$$\| $$  ______   __    __   ____| $$  ______        ' -ForegroundColor Cyan
+    Write-Host '| $$   \$$| $$ |      \ |  \  |  \ /      $$ /      \       ' -ForegroundColor Cyan
+    Write-Host '| $$      | $$  \$$$$$$\| $$  | $$|  $$$$$$$|  $$$$$$\      ' -ForegroundColor Cyan
+    Write-Host '| $$   __ | $$ /      $$| $$  | $$| $$  | $$| $$    $$      ' -ForegroundColor Cyan
+    Write-Host '| $$__/  \| $$|  $$$$$$$| $$__/ $$| $$__| $$| $$$$$$$$      ' -ForegroundColor Cyan
+    Write-Host ' \$$    $$| $$ \$$    $$ \$$    $$ \$$    $$ \$$     \       ' -ForegroundColor Cyan
+    Write-Host '  \$$$$$$  \$$  \$$$$$$$  \$$$$$$   \$$$$$$$  \$$$$$$$        ' -ForegroundColor Cyan
+    Write-Host ""
+
+    # CODE - Green color
+    Write-Host ' ______                   __                  ' -ForegroundColor Green
+    Write-Host '/      \                 |  \                ' -ForegroundColor Green
+    Write-Host '|  $$$$$$\  ______    ____| $$  ______        ' -ForegroundColor Green
+    Write-Host '| $$   \$$ /      \  /      $$ /      \       ' -ForegroundColor Green
+    Write-Host '| $$      |  $$$$$$\|  $$$$$$$|  $$$$$$\      ' -ForegroundColor Green
+    Write-Host '| $$   __ | $$  | $$| $$  | $$| $$    $$      ' -ForegroundColor Green
+    Write-Host '| $$__/  \| $$__/ $$| $$__| $$| $$$$$$$$      ' -ForegroundColor Green
+    Write-Host ' \$$    $$ \$$    $$ \$$    $$ \$$     \      ' -ForegroundColor Green
+    Write-Host '  \$$$$$$   \$$$$$$   \$$$$$$$  \$$$$$$$       ' -ForegroundColor Green
+    Write-Host ""
+
+    # WORKFLOW - Yellow color
+    Write-Host '__       __                      __         ______   __                         ' -ForegroundColor Yellow
+    Write-Host '|  \  _  |  \                    |  \       /      \ |  \                        ' -ForegroundColor Yellow
+    Write-Host '| $$ / \ | $$  ______    ______  | $$   __ |  $$$$$$\| $$  ______   __   __   __ ' -ForegroundColor Yellow
+    Write-Host '| $$/  $\| $$ /      \  /      \ | $$  /  \| $$_  \$$| $$ /      \ |  \ |  \ |  \' -ForegroundColor Yellow
+    Write-Host '| $$  $$$\ $$|  $$$$$$\|  $$$$$$\| $$_/  $$| $$ \    | $$|  $$$$$$\| $$ | $$ | $$' -ForegroundColor Yellow
+    Write-Host '| $$ $$\$$\$$| $$  | $$| $$   \$$| $$   $$ | $$$$    | $$| $$  | $$| $$ | $$ | $$' -ForegroundColor Yellow
+    Write-Host '| $$$$  \$$$$| $$__/ $$| $$      | $$$$$$\ | $$      | $$| $$__/ $$| $$_/ $$_/ $$' -ForegroundColor Yellow
+    Write-Host '| $$$    \$$$ \$$    $$| $$      | $$  \$$\| $$      | $$ \$$    $$ \$$   $$   $$' -ForegroundColor Yellow
+    Write-Host ' \$$      \$$  \$$$$$$  \$$       \$$   \$$ \$$       \$$  \$$$$$$   \$$$$$\$$$$' -ForegroundColor Yellow
+    Write-Host ""
+}
+
 function Show-Header {
-    Write-ColorOutput "==== $ScriptName v$Version ====" $ColorInfo
-    Write-ColorOutput "========================================================" $ColorInfo
+    Show-Banner
+    Write-ColorOutput "    $ScriptName v$Version" $ColorInfo
+    Write-ColorOutput "    Unified workflow system with comprehensive coordination" $ColorInfo
+    Write-ColorOutput "========================================================================" $ColorInfo
     if ($NoBackup) {
-        Write-ColorOutput "WARNING: Backup disabled - existing files will be overwritten without backup!" $ColorWarning
+        Write-ColorOutput "WARNING: Backup disabled - existing files will be overwritten!" $ColorWarning
     } else {
-        Write-ColorOutput "Auto-backup enabled - existing files will be backed up before replacement" $ColorSuccess
+        Write-ColorOutput "Auto-backup enabled - existing files will be backed up" $ColorSuccess
     }
     Write-Host ""
 }
@@ -113,38 +160,162 @@ 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
 }
 
+function Get-UserChoiceWithArrows {
+    param(
+        [string]$Prompt,
+        [string[]]$Options,
+        [int]$DefaultIndex = 0
+    )
+
+    if ($NonInteractive) {
+        Write-ColorOutput "Non-interactive mode: Using default '$($Options[$DefaultIndex])'" $ColorInfo
+        return $Options[$DefaultIndex]
+    }
+
+    # Test if we can use console features (interactive terminal)
+    $canUseConsole = $true
+    try {
+        $null = [Console]::CursorVisible
+        $null = $Host.UI.RawUI.ReadKey
+    }
+    catch {
+        $canUseConsole = $false
+    }
+
+    # Fallback to simple numbered menu if console not available
+    if (-not $canUseConsole) {
+        Write-ColorOutput "Arrow navigation not available in this environment. Using numbered menu." $ColorWarning
+        return Get-UserChoice -Prompt $Prompt -Options $Options -Default $Options[$DefaultIndex]
+    }
+
+    $selectedIndex = $DefaultIndex
+    $cursorVisible = $true
+
+    try {
+        $cursorVisible = [Console]::CursorVisible
+        [Console]::CursorVisible = $false
+    }
+    catch {
+        # Silently continue if cursor control fails
+    }
+
+    try {
+        Write-Host ""
+        Write-ColorOutput $Prompt $ColorPrompt
+        Write-Host ""
+
+        while ($true) {
+            # Display options
+            for ($i = 0; $i -lt $Options.Count; $i++) {
+                $prefix = if ($i -eq $selectedIndex) { "  > " } else { "    " }
+                $color = if ($i -eq $selectedIndex) { $ColorSuccess } else { "White" }
+
+                # Clear line and write option
+                Write-Host "`r$prefix$($Options[$i])".PadRight(80) -ForegroundColor $color
+            }
+
+            Write-Host ""
+            Write-Host "  Use " -NoNewline -ForegroundColor DarkGray
+            Write-Host "UP/DOWN" -NoNewline -ForegroundColor Yellow
+            Write-Host " arrows to navigate, " -NoNewline -ForegroundColor DarkGray
+            Write-Host "ENTER" -NoNewline -ForegroundColor Yellow
+            Write-Host " to select, or type " -NoNewline -ForegroundColor DarkGray
+            Write-Host "1-$($Options.Count)" -NoNewline -ForegroundColor Yellow
+            Write-Host "" -ForegroundColor DarkGray
+
+            # Read key
+            $key = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown")
+
+            # Handle arrow keys
+            if ($key.VirtualKeyCode -eq 38) {
+                # Up arrow
+                $selectedIndex = if ($selectedIndex -gt 0) { $selectedIndex - 1 } else { $Options.Count - 1 }
+            }
+            elseif ($key.VirtualKeyCode -eq 40) {
+                # Down arrow
+                $selectedIndex = if ($selectedIndex -lt ($Options.Count - 1)) { $selectedIndex + 1 } else { 0 }
+            }
+            elseif ($key.VirtualKeyCode -eq 13) {
+                # Enter key
+                Write-Host ""
+                return $Options[$selectedIndex]
+            }
+            elseif ($key.Character -match '^\d$') {
+                # Number key
+                $num = [int]::Parse($key.Character)
+                if ($num -ge 1 -and $num -le $Options.Count) {
+                    Write-Host ""
+                    return $Options[$num - 1]
+                }
+            }
+
+            # Move cursor back up to redraw menu
+            $linesToMove = $Options.Count + 2
+            try {
+                for ($i = 0; $i -lt $linesToMove; $i++) {
+                    [Console]::SetCursorPosition(0, [Console]::CursorTop - 1)
+                }
+            }
+            catch {
+                # If cursor positioning fails, just continue
+                break
+            }
+        }
+    }
+    finally {
+        try {
+            [Console]::CursorVisible = $cursorVisible
+        }
+        catch {
+            # Silently continue if cursor control fails
+        }
+    }
+}
+
 function Get-UserChoice {
     param(
         [string]$Prompt,
         [string[]]$Options,
         [string]$Default = $null
     )
-    
+
     if ($NonInteractive -and $Default) {
         Write-ColorOutput "Non-interactive mode: Using default '$Default'" $ColorInfo
         return $Default
     }
-    
+
     Write-ColorOutput $Prompt $ColorPrompt
     for ($i = 0; $i -lt $Options.Count; $i++) {
         if ($Default -and $Options[$i] -eq $Default) {
@@ -154,18 +325,18 @@ function Get-UserChoice {
         }
         Write-Host "  $($i + 1). $($Options[$i])$marker"
     }
-    
+
     do {
         $input = Read-Host "Please select (1-$($Options.Count))"
         if ([string]::IsNullOrWhiteSpace($input) -and $Default) {
             return $Default
         }
-        
+
         $index = $null
         if ([int]::TryParse($input, [ref]$index) -and $index -ge 1 -and $index -le $Options.Count) {
             return $Options[$index - 1]
         }
-        
+
         Write-ColorOutput "Invalid selection. Please enter a number between 1 and $($Options.Count)" $ColorWarning
     } while ($true)
 }
@@ -455,26 +626,70 @@ 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
-    
+
     # Determine user profile directory
     $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
-    
+
     # Source paths
     $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) {
-            $existingFiles = Get-ChildItem $globalClaudeDir -Recurse -File -ErrorAction SilentlyContinue
+        if ((Test-Path $globalClaudeDir) -or (Test-Path $globalCodexDir) -or (Test-Path $globalGeminiDir)) {
+            $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
@@ -485,15 +700,27 @@ function Install-Global {
             Write-ColorOutput "Backup folder created: $backupFolder" $ColorInfo
         }
     }
-    
+
     # Merge .claude directory contents (don't replace entire directory)
     Write-ColorOutput "Merging .claude directory contents..." $ColorInfo
     $claudeMerged = Merge-DirectoryContents -Source $sourceClaudeDir -Destination $globalClaudeDir -Description ".claude directory contents" -BackupFolder $backupFolder
-    
+
     # Handle CLAUDE.md file in .claude directory
     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) {
@@ -502,16 +729,227 @@ function Install-Global {
             Write-ColorOutput "Removed empty backup folder" $ColorInfo
         }
     }
-    
+
+    return $true
+}
+
+function Install-Path {
+    param(
+        [string]$TargetDirectory
+    )
+
+    Write-ColorOutput "Installing Claude Code Workflow System in hybrid mode..." $ColorInfo
+    Write-ColorOutput "Local path: $TargetDirectory" $ColorInfo
+
+    # Determine user profile directory for global files
+    $userProfile = [Environment]::GetFolderPath("UserProfile")
+    $globalClaudeDir = Join-Path $userProfile ".claude"
+
+    Write-ColorOutput "Global path: $userProfile" $ColorInfo
+
+    # Source paths
+    $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 - 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 $localCodexDir) -or (Test-Path $localGeminiDir) -or (Test-Path $globalClaudeDir)) {
+            $backupFolder = Get-BackupDirectory -TargetDirectory $TargetDirectory
+            Write-ColorOutput "Backup folder created: $backupFolder" $ColorInfo
+        }
+    }
+
+    # Create local .claude directory
+    if (-not (Test-Path $localClaudeDir)) {
+        New-Item -ItemType Directory -Path $localClaudeDir -Force | Out-Null
+        Write-ColorOutput "Created local .claude directory" $ColorSuccess
+    }
+
+    # Local folders to install (agents, commands, output-styles)
+    $localFolders = @("agents", "commands", "output-styles")
+
+    Write-ColorOutput "Installing local components (agents, commands, output-styles)..." $ColorInfo
+    foreach ($folder in $localFolders) {
+        $sourceFolderPath = Join-Path $sourceClaudeDir $folder
+        $destFolderPath = Join-Path $localClaudeDir $folder
+
+        if (Test-Path $sourceFolderPath) {
+            if (Test-Path $destFolderPath) {
+                if ($backupFolder) {
+                    Backup-DirectoryToFolder -DirectoryPath $destFolderPath -BackupFolder $backupFolder
+                }
+            }
+
+            Copy-DirectoryRecursive -Source $sourceFolderPath -Destination $destFolderPath
+            Write-ColorOutput "Installed local folder: $folder" $ColorSuccess
+        } else {
+            Write-ColorOutput "WARNING: Source folder not found: $folder" $ColorWarning
+        }
+    }
+
+    # Global components - exclude local folders
+    Write-ColorOutput "Installing global components to $globalClaudeDir..." $ColorInfo
+
+    # Get all items from source, excluding local folders
+    $sourceItems = Get-ChildItem -Path $sourceClaudeDir -Recurse -File | Where-Object {
+        $relativePath = $_.FullName.Substring($sourceClaudeDir.Length + 1)
+        $topFolder = $relativePath.Split([System.IO.Path]::DirectorySeparatorChar)[0]
+        $topFolder -notin $localFolders
+    }
+
+    $mergedCount = 0
+    foreach ($item in $sourceItems) {
+        $relativePath = $item.FullName.Substring($sourceClaudeDir.Length + 1)
+        $destinationPath = Join-Path $globalClaudeDir $relativePath
+
+        # Ensure destination directory exists
+        $destinationDir = Split-Path $destinationPath -Parent
+        if (-not (Test-Path $destinationDir)) {
+            New-Item -ItemType Directory -Path $destinationDir -Force | Out-Null
+        }
+
+        # Handle file merging
+        if (Test-Path $destinationPath) {
+            if ($BackupAll -and -not $NoBackup) {
+                if ($backupFolder) {
+                    Backup-FileToFolder -FilePath $destinationPath -BackupFolder $backupFolder
+                }
+                Copy-Item -Path $item.FullName -Destination $destinationPath -Force
+                $mergedCount++
+            } elseif ($NoBackup) {
+                if (Confirm-Action "File '$relativePath' already exists in global location. Replace it? (NO BACKUP)" -DefaultYes:$false) {
+                    Copy-Item -Path $item.FullName -Destination $destinationPath -Force
+                    $mergedCount++
+                }
+            } elseif (Confirm-Action "File '$relativePath' already exists in global location. Replace it?" -DefaultYes:$false) {
+                if ($backupFolder) {
+                    Backup-FileToFolder -FilePath $destinationPath -BackupFolder $backupFolder
+                }
+                Copy-Item -Path $item.FullName -Destination $destinationPath -Force
+                $mergedCount++
+            }
+        } else {
+            Copy-Item -Path $item.FullName -Destination $destinationPath -Force
+            $mergedCount++
+        }
+    }
+
+    Write-ColorOutput "Merged $mergedCount files to global location" $ColorSuccess
+
+    # Handle CLAUDE.md file in global .claude directory
+    $globalClaudeMd = Join-Path $globalClaudeDir "CLAUDE.md"
+    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) {
+            Remove-Item -Path $backupFolder -Force
+            Write-ColorOutput "Removed empty backup folder" $ColorInfo
+        }
+    }
+
     return $true
 }
 
 
 function Get-InstallationMode {
-    Write-ColorOutput "Installation mode: Global (installing to user profile ~/.claude/)" $ColorInfo
+    if ($InstallMode) {
+        Write-ColorOutput "Installation mode: $InstallMode" $ColorInfo
+        return $InstallMode
+    }
+
+    $modes = @(
+        "Global - Install to user profile (~/.claude/)",
+        "Path - Install to custom directory (partial local + global)"
+    )
+
+    Write-Host ""
+    $selection = Get-UserChoiceWithArrows -Prompt "Choose installation mode:" -Options $modes -DefaultIndex 0
+
+    if ($selection -like "Global*") {
+        return "Global"
+    } elseif ($selection -like "Path*") {
+        return "Path"
+    }
+
     return "Global"
 }
 
+function Get-InstallationPath {
+    param(
+        [string]$Mode
+    )
+
+    if ($Mode -eq "Global") {
+        return [Environment]::GetFolderPath("UserProfile")
+    }
+
+    if ($TargetPath) {
+        if (Test-Path $TargetPath) {
+            return $TargetPath
+        }
+        Write-ColorOutput "WARNING: Specified target path does not exist: $TargetPath" $ColorWarning
+    }
+
+    # Interactive path selection
+    do {
+        Write-Host ""
+        Write-ColorOutput "Enter the target directory path for installation:" $ColorPrompt
+        Write-ColorOutput "(This will install agents, commands, output-styles locally, other files globally)" $ColorInfo
+        $path = Read-Host "Path"
+
+        if ([string]::IsNullOrWhiteSpace($path)) {
+            Write-ColorOutput "Path cannot be empty" $ColorWarning
+            continue
+        }
+
+        # Expand environment variables and relative paths
+        $expandedPath = [System.Environment]::ExpandEnvironmentVariables($path)
+        $expandedPath = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($expandedPath)
+
+        if (Test-Path $expandedPath) {
+            return $expandedPath
+        }
+
+        Write-ColorOutput "Path does not exist: $expandedPath" $ColorWarning
+        if (Confirm-Action "Create this directory?" -DefaultYes) {
+            try {
+                New-Item -ItemType Directory -Path $expandedPath -Force | Out-Null
+                Write-ColorOutput "Directory created successfully" $ColorSuccess
+                return $expandedPath
+            } catch {
+                Write-ColorOutput "Failed to create directory: $($_.Exception.Message)" $ColorError
+            }
+        }
+    } while ($true)
+}
+
 
 function Show-Summary {
     param(
@@ -519,17 +957,27 @@ function Show-Summary {
         [string]$Path,
         [bool]$Success
     )
-    
+
     Write-Host ""
     if ($Success) {
         Write-ColorOutput "Installation completed successfully!" $ColorSuccess
     } else {
         Write-ColorOutput "Installation completed with warnings" $ColorWarning
     }
-    
+
     Write-ColorOutput "Installation Details:" $ColorInfo
     Write-Host "  Mode: $Mode"
-    Write-Host "  Path: $Path"
+
+    if ($Mode -eq "Path") {
+        Write-Host "  Local Path: $Path"
+        Write-Host "  Global Path: $([Environment]::GetFolderPath('UserProfile'))"
+        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) {
         Write-Host "  Backup: Disabled (no backup created)"
     } elseif ($BackupAll) {
@@ -537,15 +985,17 @@ function Show-Summary {
     } else {
         Write-Host "  Backup: Enabled (default behavior)"
     }
-    
+
     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 "3. Start using Claude Code with Agent workflow coordination!"
-    Write-Host "4. Use /workflow commands for task execution"
-    Write-Host "5. Use /update-memory commands for memory system management"
-    
+    Write-Host "2. Review .codex/Agent.md - Codex agent execution protocol"
+    Write-Host "3. Review .gemini/CLAUDE.md - Gemini agent execution protocol"
+    Write-Host "4. Configure settings - Edit .claude/settings.local.json as needed"
+    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
     Write-ColorOutput "Features: Unified workflow system with comprehensive file output generation" $ColorInfo
@@ -553,48 +1003,57 @@ function Show-Summary {
 
 function Main {
     Show-Header
-    
+
     # Test prerequisites
     Write-ColorOutput "Checking system requirements..." $ColorInfo
     if (-not (Test-Prerequisites)) {
         Write-ColorOutput "Prerequisites check failed!" $ColorError
         return 1
     }
-    
+
     try {
         # Get installation mode
         $mode = Get-InstallationMode
         $installPath = ""
         $success = $false
-        
-        $installPath = [Environment]::GetFolderPath("UserProfile")
-        $success = Install-Global
-        
-        Show-Summary -Mode $mode -Path $installPath -Success $success
-        
+
+        if ($mode -eq "Global") {
+            $installPath = [Environment]::GetFolderPath("UserProfile")
+            $result = Install-Global
+            $success = $result -eq $true
+        }
+        elseif ($mode -eq "Path") {
+            $installPath = Get-InstallationPath -Mode $mode
+            $result = Install-Path -TargetDirectory $installPath
+            $success = $result -eq $true
+        }
+
+        Show-Summary -Mode $mode -Path $installPath -Success ([bool]$success)
+
         # Wait for user confirmation before exit in interactive mode
         if (-not $NonInteractive) {
             Write-Host ""
             Write-ColorOutput "Installation completed. Press any key to exit..." $ColorPrompt
             $null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown")
         }
-        
+
         if ($success) {
             return 0
         } else {
             return 1
         }
-        
+
     } catch {
         Write-ColorOutput "CRITICAL ERROR: $($_.Exception.Message)" $ColorError
-        
+        Write-ColorOutput "Stack trace: $($_.ScriptStackTrace)" $ColorError
+
         # Wait for user confirmation before exit in interactive mode
         if (-not $NonInteractive) {
             Write-Host ""
             Write-ColorOutput "An error occurred. Press any key to exit..." $ColorPrompt
             $null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown")
         }
-        
+
         return 1
     }
 }

Install-Claude.sh

@@ -0,0 +1,834 @@
+#!/usr/bin/env bash
+# Claude Code Workflow System Interactive Installer
+# Installation script for Claude Code Workflow System with Agent coordination and distributed memory system.
+# Installs globally to user profile directory (~/.claude) by default.
+
+set -e  # Exit on error
+
+# Script metadata
+SCRIPT_NAME="Claude Code Workflow System Installer"
+VERSION="2.1.0"
+
+# Colors for output
+COLOR_RESET='\033[0m'
+COLOR_SUCCESS='\033[0;32m'
+COLOR_INFO='\033[0;36m'
+COLOR_WARNING='\033[0;33m'
+COLOR_ERROR='\033[0;31m'
+COLOR_PROMPT='\033[0;35m'
+
+# Default parameters
+INSTALL_MODE=""
+TARGET_PATH=""
+FORCE=false
+NON_INTERACTIVE=false
+BACKUP_ALL=true  # Enabled by default
+NO_BACKUP=false
+
+# Functions
+function write_color() {
+    local message="$1"
+    local color="${2:-$COLOR_RESET}"
+    echo -e "${color}${message}${COLOR_RESET}"
+}
+
+function show_banner() {
+    echo ""
+    # CLAUDE - Cyan color
+    write_color '  ______   __                            __                   ' "$COLOR_INFO"
+    write_color ' /      \ |  \                          |  \                 ' "$COLOR_INFO"
+    write_color '|  $$$$$$\| $$  ______   __    __   ____| $$  ______        ' "$COLOR_INFO"
+    write_color '| $$   \$$| $$ |      \ |  \  |  \ /      $$ /      \       ' "$COLOR_INFO"
+    write_color '| $$      | $$  \$$$$$$\| $$  | $$|  $$$$$$$|  $$$$$$\      ' "$COLOR_INFO"
+    write_color '| $$   __ | $$ /      $$| $$  | $$| $$  | $$| $$    $$      ' "$COLOR_INFO"
+    write_color '| $$__/  \| $$|  $$$$$$$| $$__/ $$| $$__| $$| $$$$$$$$      ' "$COLOR_INFO"
+    write_color ' \$$    $$| $$ \$$    $$ \$$    $$ \$$    $$ \$$     \       ' "$COLOR_INFO"
+    write_color '  \$$$$$$  \$$  \$$$$$$$  \$$$$$$   \$$$$$$$  \$$$$$$$        ' "$COLOR_INFO"
+    echo ""
+
+    # CODE - Green color
+    write_color ' ______                   __                  ' "$COLOR_SUCCESS"
+    write_color '/      \                 |  \                ' "$COLOR_SUCCESS"
+    write_color '|  $$$$$$\  ______    ____| $$  ______        ' "$COLOR_SUCCESS"
+    write_color '| $$   \$$ /      \  /      $$ /      \       ' "$COLOR_SUCCESS"
+    write_color '| $$      |  $$$$$$\|  $$$$$$$|  $$$$$$\      ' "$COLOR_SUCCESS"
+    write_color '| $$   __ | $$  | $$| $$  | $$| $$    $$      ' "$COLOR_SUCCESS"
+    write_color '| $$__/  \| $$__/ $$| $$__| $$| $$$$$$$$      ' "$COLOR_SUCCESS"
+    write_color ' \$$    $$ \$$    $$ \$$    $$ \$$     \      ' "$COLOR_SUCCESS"
+    write_color '  \$$$$$$   \$$$$$$   \$$$$$$$  \$$$$$$$       ' "$COLOR_SUCCESS"
+    echo ""
+
+    # WORKFLOW - Yellow color
+    write_color '__       __                      __         ______   __                         ' "$COLOR_WARNING"
+    write_color '|  \  _  |  \                    |  \       /      \ |  \                        ' "$COLOR_WARNING"
+    write_color '| $$ / \ | $$  ______    ______  | $$   __ |  $$$$$$\| $$  ______   __   __   __ ' "$COLOR_WARNING"
+    write_color '| $$/  $\| $$ /      \  /      \ | $$  /  \| $$_  \$$| $$ /      \ |  \ |  \ |  \' "$COLOR_WARNING"
+    write_color '| $$  $$$\ $$|  $$$$$$\|  $$$$$$\| $$_/  $$| $$ \    | $$|  $$$$$$\| $$ | $$ | $$' "$COLOR_WARNING"
+    write_color '| $$ $$\$$\$$| $$  | $$| $$   \$$| $$   $$ | $$$$    | $$| $$  | $$| $$ | $$ | $$' "$COLOR_WARNING"
+    write_color '| $$$$  \$$$$| $$__/ $$| $$      | $$$$$$\ | $$      | $$| $$__/ $$| $$_/ $$_/ $$' "$COLOR_WARNING"
+    write_color '| $$$    \$$$ \$$    $$| $$      | $$  \$$\| $$      | $$ \$$    $$ \$$   $$   $$' "$COLOR_WARNING"
+    write_color ' \$$      \$$  \$$$$$$  \$$       \$$   \$$ \$$       \$$  \$$$$$$   \$$$$$\$$$$' "$COLOR_WARNING"
+    echo ""
+}
+
+function show_header() {
+    show_banner
+    write_color "    $SCRIPT_NAME v$VERSION" "$COLOR_INFO"
+    write_color "    Unified workflow system with comprehensive coordination" "$COLOR_INFO"
+    write_color "========================================================================" "$COLOR_INFO"
+
+    if [ "$NO_BACKUP" = true ]; then
+        write_color "WARNING: Backup disabled - existing files will be overwritten!" "$COLOR_WARNING"
+    else
+        write_color "Auto-backup enabled - existing files will be backed up" "$COLOR_SUCCESS"
+    fi
+    echo ""
+}
+
+function test_prerequisites() {
+    # Test bash version
+    if [ "${BASH_VERSINFO[0]}" -lt 2 ]; then
+        write_color "ERROR: Bash 2.0 or higher is required" "$COLOR_ERROR"
+        write_color "Current version: ${BASH_VERSION}" "$COLOR_ERROR"
+        return 1
+    fi
+
+    # Test source files exist
+    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"
+        return 1
+    fi
+
+    if [ ! -f "$claude_md" ]; then
+        write_color "ERROR: CLAUDE.md file not found in $script_dir" "$COLOR_ERROR"
+        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
+}
+
+function get_user_choice() {
+    local prompt="$1"
+    shift
+    local options=("$@")
+    local default_index=0
+
+    if [ "$NON_INTERACTIVE" = true ]; then
+        write_color "Non-interactive mode: Using default '${options[$default_index]}'" "$COLOR_INFO" >&2
+        echo "${options[$default_index]}"
+        return
+    fi
+
+    # Output prompts to stderr so they don't interfere with function return value
+    echo "" >&2
+    write_color "$prompt" "$COLOR_PROMPT" >&2
+    echo "" >&2
+
+    for i in "${!options[@]}"; do
+        echo "  $((i + 1)). ${options[$i]}" >&2
+    done
+
+    echo "" >&2
+
+    while true; do
+        read -p "Please select (1-${#options[@]}): " choice
+
+        if [[ "$choice" =~ ^[0-9]+$ ]] && [ "$choice" -ge 1 ] && [ "$choice" -le "${#options[@]}" ]; then
+            echo "${options[$((choice - 1))]}"
+            return
+        fi
+
+        write_color "Invalid selection. Please enter a number between 1 and ${#options[@]}" "$COLOR_WARNING" >&2
+    done
+}
+
+function confirm_action() {
+    local message="$1"
+    local default_yes="${2:-false}"
+
+    if [ "$FORCE" = true ]; then
+        write_color "Force mode: Proceeding with '$message'" "$COLOR_INFO"
+        return 0
+    fi
+
+    if [ "$NON_INTERACTIVE" = true ]; then
+        if [ "$default_yes" = true ]; then
+            write_color "Non-interactive mode: $message - Yes" "$COLOR_INFO"
+            return 0
+        else
+            write_color "Non-interactive mode: $message - No" "$COLOR_INFO"
+            return 1
+        fi
+    fi
+
+    local prompt
+    if [ "$default_yes" = true ]; then
+        prompt="(Y/n)"
+    else
+        prompt="(y/N)"
+    fi
+
+    while true; do
+        read -p "$message $prompt " response
+
+        if [ -z "$response" ]; then
+            [ "$default_yes" = true ] && return 0 || return 1
+        fi
+
+        case "${response,,}" in
+            y|yes) return 0 ;;
+            n|no) return 1 ;;
+            *) write_color "Please answer 'y' or 'n'" "$COLOR_WARNING" ;;
+        esac
+    done
+}
+
+function get_backup_directory() {
+    local target_dir="$1"
+    local timestamp=$(date +"%Y%m%d-%H%M%S")
+    local backup_dir="${target_dir}/claude-backup-${timestamp}"
+
+    mkdir -p "$backup_dir"
+    echo "$backup_dir"
+}
+
+function backup_file_to_folder() {
+    local file_path="$1"
+    local backup_folder="$2"
+
+    if [ ! -f "$file_path" ]; then
+        return 1
+    fi
+
+    local file_name=$(basename "$file_path")
+    local file_dir=$(dirname "$file_path")
+    local relative_path=""
+
+    # Try to determine relative path structure
+    if [[ "$file_dir" == *".claude"* ]]; then
+        relative_path="${file_dir#*.claude/}"
+    fi
+
+    # Create subdirectory structure in backup if needed
+    local backup_sub_dir="$backup_folder"
+    if [ -n "$relative_path" ]; then
+        backup_sub_dir="${backup_folder}/${relative_path}"
+        mkdir -p "$backup_sub_dir"
+    fi
+
+    local backup_file_path="${backup_sub_dir}/${file_name}"
+
+    if cp "$file_path" "$backup_file_path"; then
+        write_color "Backed up: $file_name" "$COLOR_INFO"
+        return 0
+    else
+        write_color "WARNING: Failed to backup file $file_path" "$COLOR_WARNING"
+        return 1
+    fi
+}
+
+function backup_directory_to_folder() {
+    local dir_path="$1"
+    local backup_folder="$2"
+
+    if [ ! -d "$dir_path" ]; then
+        return 1
+    fi
+
+    local dir_name=$(basename "$dir_path")
+    local backup_dir_path="${backup_folder}/${dir_name}"
+
+    if cp -r "$dir_path" "$backup_dir_path"; then
+        write_color "Backed up directory: $dir_name" "$COLOR_INFO"
+        return 0
+    else
+        write_color "WARNING: Failed to backup directory $dir_path" "$COLOR_WARNING"
+        return 1
+    fi
+}
+
+function copy_directory_recursive() {
+    local source="$1"
+    local destination="$2"
+
+    if [ ! -d "$source" ]; then
+        write_color "ERROR: Source directory does not exist: $source" "$COLOR_ERROR"
+        return 1
+    fi
+
+    mkdir -p "$destination"
+
+    if cp -r "$source/"* "$destination/"; then
+        write_color "✓ Directory copied: $source -> $destination" "$COLOR_SUCCESS"
+        return 0
+    else
+        write_color "ERROR: Failed to copy directory" "$COLOR_ERROR"
+        return 1
+    fi
+}
+
+function copy_file_to_destination() {
+    local source="$1"
+    local destination="$2"
+    local description="${3:-file}"
+    local backup_folder="${4:-}"
+
+    if [ -f "$destination" ]; then
+        # Use BackupAll mode for automatic backup
+        if [ "$BACKUP_ALL" = true ] && [ "$NO_BACKUP" = false ]; then
+            if [ -n "$backup_folder" ]; then
+                backup_file_to_folder "$destination" "$backup_folder"
+                write_color "Auto-backed up: $description" "$COLOR_SUCCESS"
+            fi
+            cp "$source" "$destination"
+            write_color "$description updated (with backup)" "$COLOR_SUCCESS"
+            return 0
+        elif [ "$NO_BACKUP" = true ]; then
+            if confirm_action "$description already exists. Replace it? (NO BACKUP)" false; then
+                cp "$source" "$destination"
+                write_color "$description updated (no backup)" "$COLOR_WARNING"
+                return 0
+            else
+                write_color "Skipping $description installation" "$COLOR_WARNING"
+                return 1
+            fi
+        elif confirm_action "$description already exists. Replace it?" false; then
+            if [ -n "$backup_folder" ]; then
+                backup_file_to_folder "$destination" "$backup_folder"
+                write_color "Existing $description backed up" "$COLOR_SUCCESS"
+            fi
+            cp "$source" "$destination"
+            write_color "$description updated" "$COLOR_SUCCESS"
+            return 0
+        else
+            write_color "Skipping $description installation" "$COLOR_WARNING"
+            return 1
+        fi
+    else
+        # Ensure destination directory exists
+        local dest_dir=$(dirname "$destination")
+        mkdir -p "$dest_dir"
+        cp "$source" "$destination"
+        write_color "✓ $description installed" "$COLOR_SUCCESS"
+        return 0
+    fi
+}
+
+function merge_directory_contents() {
+    local source="$1"
+    local destination="$2"
+    local description="${3:-directory contents}"
+    local backup_folder="${4:-}"
+
+    if [ ! -d "$source" ]; then
+        write_color "WARNING: Source $description not found: $source" "$COLOR_WARNING"
+        return 1
+    fi
+
+    mkdir -p "$destination"
+    write_color "Created destination directory: $destination" "$COLOR_INFO"
+
+    local merged_count=0
+    local skipped_count=0
+
+    # Find all files recursively
+    while IFS= read -r -d '' file; do
+        local relative_path="${file#$source/}"
+        local dest_path="${destination}/${relative_path}"
+        local dest_dir=$(dirname "$dest_path")
+
+        mkdir -p "$dest_dir"
+
+        if [ -f "$dest_path" ]; then
+            local file_name=$(basename "$relative_path")
+
+            if [ "$BACKUP_ALL" = true ] && [ "$NO_BACKUP" = false ]; then
+                if [ -n "$backup_folder" ]; then
+                    backup_file_to_folder "$dest_path" "$backup_folder"
+                    write_color "Auto-backed up: $file_name" "$COLOR_INFO"
+                fi
+                cp "$file" "$dest_path"
+                ((merged_count++))
+            elif [ "$NO_BACKUP" = true ]; then
+                if confirm_action "File '$relative_path' already exists. Replace it? (NO BACKUP)" false; then
+                    cp "$file" "$dest_path"
+                    ((merged_count++))
+                else
+                    write_color "Skipped $file_name (no backup)" "$COLOR_WARNING"
+                    ((skipped_count++))
+                fi
+            elif confirm_action "File '$relative_path' already exists. Replace it?" false; then
+                if [ -n "$backup_folder" ]; then
+                    backup_file_to_folder "$dest_path" "$backup_folder"
+                    write_color "Backed up existing $file_name" "$COLOR_INFO"
+                fi
+                cp "$file" "$dest_path"
+                ((merged_count++))
+            else
+                write_color "Skipped $file_name" "$COLOR_WARNING"
+                ((skipped_count++))
+            fi
+        else
+            cp "$file" "$dest_path"
+            ((merged_count++))
+        fi
+    done < <(find "$source" -type f -print0)
+
+    write_color "✓ Merged $merged_count files, skipped $skipped_count files" "$COLOR_SUCCESS"
+    return 0
+}
+
+function install_global() {
+    write_color "Installing Claude Code Workflow System globally..." "$COLOR_INFO"
+
+    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"
+
+    # Source paths
+    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
+            has_existing_files=true
+        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
+    fi
+
+    # Merge .claude directory contents
+    write_color "Merging .claude directory contents..." "$COLOR_INFO"
+    merge_directory_contents "$source_claude_dir" "$global_claude_dir" ".claude directory contents" "$backup_folder"
+
+    # Handle CLAUDE.md file
+    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
+            rm -rf "$backup_folder"
+            write_color "Removed empty backup folder" "$COLOR_INFO"
+        fi
+    fi
+
+    return 0
+}
+
+function install_path() {
+    local target_dir="$1"
+
+    write_color "Installing Claude Code Workflow System in hybrid mode..." "$COLOR_INFO"
+    write_color "Local path: $target_dir" "$COLOR_INFO"
+
+    local user_home="$HOME"
+    local global_claude_dir="${user_home}/.claude"
+    write_color "Global path: $user_home" "$COLOR_INFO"
+
+    # Source paths
+    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 "$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
+    fi
+
+    # Create local .claude directory
+    mkdir -p "$local_claude_dir"
+    write_color "✓ Created local .claude directory" "$COLOR_SUCCESS"
+
+    # Local folders to install
+    local local_folders=("agents" "commands" "output-styles")
+
+    write_color "Installing local components (agents, commands, output-styles)..." "$COLOR_INFO"
+    for folder in "${local_folders[@]}"; do
+        local source_folder="${source_claude_dir}/${folder}"
+        local dest_folder="${local_claude_dir}/${folder}"
+
+        if [ -d "$source_folder" ]; then
+            if [ -d "$dest_folder" ] && [ -n "$backup_folder" ]; then
+                backup_directory_to_folder "$dest_folder" "$backup_folder"
+            fi
+
+            copy_directory_recursive "$source_folder" "$dest_folder"
+            write_color "✓ Installed local folder: $folder" "$COLOR_SUCCESS"
+        else
+            write_color "WARNING: Source folder not found: $folder" "$COLOR_WARNING"
+        fi
+    done
+
+    # Global components - exclude local folders
+    write_color "Installing global components to $global_claude_dir..." "$COLOR_INFO"
+
+    local merged_count=0
+
+    while IFS= read -r -d '' file; do
+        local relative_path="${file#$source_claude_dir/}"
+        local top_folder=$(echo "$relative_path" | cut -d'/' -f1)
+
+        # Skip local folders
+        if [[ " ${local_folders[*]} " =~ " ${top_folder} " ]]; then
+            continue
+        fi
+
+        local dest_path="${global_claude_dir}/${relative_path}"
+        local dest_dir=$(dirname "$dest_path")
+
+        mkdir -p "$dest_dir"
+
+        if [ -f "$dest_path" ]; then
+            if [ "$BACKUP_ALL" = true ] && [ "$NO_BACKUP" = false ]; then
+                if [ -n "$backup_folder" ]; then
+                    backup_file_to_folder "$dest_path" "$backup_folder"
+                fi
+                cp "$file" "$dest_path"
+                ((merged_count++))
+            elif [ "$NO_BACKUP" = true ]; then
+                if confirm_action "File '$relative_path' already exists in global location. Replace it? (NO BACKUP)" false; then
+                    cp "$file" "$dest_path"
+                    ((merged_count++))
+                fi
+            elif confirm_action "File '$relative_path' already exists in global location. Replace it?" false; then
+                if [ -n "$backup_folder" ]; then
+                    backup_file_to_folder "$dest_path" "$backup_folder"
+                fi
+                cp "$file" "$dest_path"
+                ((merged_count++))
+            fi
+        else
+            cp "$file" "$dest_path"
+            ((merged_count++))
+        fi
+    done < <(find "$source_claude_dir" -type f -print0)
+
+    write_color "✓ Merged $merged_count files to global location" "$COLOR_SUCCESS"
+
+    # Handle CLAUDE.md file in global .claude directory
+    local global_claude_md="${global_claude_dir}/CLAUDE.md"
+    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
+            rm -rf "$backup_folder"
+            write_color "Removed empty backup folder" "$COLOR_INFO"
+        fi
+    fi
+
+    return 0
+}
+
+function get_installation_mode() {
+    if [ -n "$INSTALL_MODE" ]; then
+        write_color "Installation mode: $INSTALL_MODE" "$COLOR_INFO"
+        echo "$INSTALL_MODE"
+        return
+    fi
+
+    local modes=(
+        "Global - Install to user profile (~/.claude/)"
+        "Path - Install to custom directory (partial local + global)"
+    )
+
+    local selection=$(get_user_choice "Choose installation mode:" "${modes[@]}")
+
+    if [[ "$selection" == Global* ]]; then
+        echo "Global"
+    elif [[ "$selection" == Path* ]]; then
+        echo "Path"
+    else
+        echo "Global"
+    fi
+}
+
+function get_installation_path() {
+    local mode="$1"
+
+    if [ "$mode" = "Global" ]; then
+        echo "$HOME"
+        return
+    fi
+
+    if [ -n "$TARGET_PATH" ]; then
+        if [ -d "$TARGET_PATH" ]; then
+            echo "$TARGET_PATH"
+            return
+        fi
+        write_color "WARNING: Specified target path does not exist: $TARGET_PATH" "$COLOR_WARNING"
+    fi
+
+    # Interactive path selection
+    while true; do
+        echo ""
+        write_color "Enter the target directory path for installation:" "$COLOR_PROMPT"
+        write_color "(This will install agents, commands, output-styles locally, other files globally)" "$COLOR_INFO"
+        read -p "Path: " path
+
+        if [ -z "$path" ]; then
+            write_color "Path cannot be empty" "$COLOR_WARNING"
+            continue
+        fi
+
+        # Expand ~ and environment variables
+        path=$(eval echo "$path")
+
+        if [ -d "$path" ]; then
+            echo "$path"
+            return
+        fi
+
+        write_color "Path does not exist: $path" "$COLOR_WARNING"
+        if confirm_action "Create this directory?" true; then
+            if mkdir -p "$path"; then
+                write_color "✓ Directory created successfully" "$COLOR_SUCCESS"
+                echo "$path"
+                return
+            else
+                write_color "ERROR: Failed to create directory" "$COLOR_ERROR"
+            fi
+        fi
+    done
+}
+
+function show_summary() {
+    local mode="$1"
+    local path="$2"
+    local success="$3"
+
+    echo ""
+    if [ "$success" = true ]; then
+        write_color "✓ Installation completed successfully!" "$COLOR_SUCCESS"
+    else
+        write_color "Installation completed with warnings" "$COLOR_WARNING"
+    fi
+
+    write_color "Installation Details:" "$COLOR_INFO"
+    echo "  Mode: $mode"
+
+    if [ "$mode" = "Path" ]; then
+        echo "  Local Path: $path"
+        echo "  Global Path: $HOME"
+        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
+        echo "  Backup: Disabled (no backup created)"
+    elif [ "$BACKUP_ALL" = true ]; then
+        echo "  Backup: Enabled (automatic backup of all existing files)"
+    else
+        echo "  Backup: Enabled (default behavior)"
+    fi
+
+    echo ""
+    write_color "Next steps:" "$COLOR_INFO"
+    echo "1. Review CLAUDE.md - Customize guidelines for your project"
+    echo "2. Review .codex/Agent.md - Codex agent execution protocol"
+    echo "3. Review .gemini/CLAUDE.md - Gemini agent execution protocol"
+    echo "4. Configure settings - Edit .claude/settings.local.json as needed"
+    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"
+    write_color "Features: Unified workflow system with comprehensive file output generation" "$COLOR_INFO"
+}
+
+function parse_arguments() {
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            -InstallMode)
+                INSTALL_MODE="$2"
+                shift 2
+                ;;
+            -TargetPath)
+                TARGET_PATH="$2"
+                shift 2
+                ;;
+            -Force)
+                FORCE=true
+                shift
+                ;;
+            -NonInteractive)
+                NON_INTERACTIVE=true
+                shift
+                ;;
+            -BackupAll)
+                BACKUP_ALL=true
+                NO_BACKUP=false
+                shift
+                ;;
+            -NoBackup)
+                NO_BACKUP=true
+                BACKUP_ALL=false
+                shift
+                ;;
+            --help|-h)
+                show_help
+                exit 0
+                ;;
+            *)
+                write_color "Unknown option: $1" "$COLOR_ERROR"
+                show_help
+                exit 1
+                ;;
+        esac
+    done
+}
+
+function show_help() {
+    cat << EOF
+$SCRIPT_NAME v$VERSION
+
+Usage: $0 [OPTIONS]
+
+Options:
+    -InstallMode <mode>   Installation mode: Global or Path
+    -TargetPath <path>    Target path for Path installation mode
+    -Force                Skip confirmation prompts
+    -NonInteractive       Run in non-interactive mode with default options
+    -BackupAll            Automatically backup all existing files (default)
+    -NoBackup             Disable automatic backup functionality
+    --help, -h            Show this help message
+
+Examples:
+    # Interactive installation
+    $0
+
+    # Global installation without prompts
+    $0 -InstallMode Global -Force
+
+    # Path installation with custom directory
+    $0 -InstallMode Path -TargetPath /opt/claude-code-workflow
+
+    # Installation without backup
+    $0 -NoBackup
+
+EOF
+}
+
+function main() {
+    show_header
+
+    # Test prerequisites
+    write_color "Checking system requirements..." "$COLOR_INFO"
+    if ! test_prerequisites; then
+        write_color "Prerequisites check failed!" "$COLOR_ERROR"
+        return 1
+    fi
+
+    local mode=$(get_installation_mode)
+    local install_path=""
+    local success=false
+
+    if [ "$mode" = "Global" ]; then
+        install_path="$HOME"
+        if install_global; then
+            success=true
+        fi
+    elif [ "$mode" = "Path" ]; then
+        install_path=$(get_installation_path "$mode")
+        if install_path "$install_path"; then
+            success=true
+        fi
+    fi
+
+    show_summary "$mode" "$install_path" "$success"
+
+    # Wait for user confirmation in interactive mode
+    if [ "$NON_INTERACTIVE" != true ]; then
+        echo ""
+        write_color "Installation completed. Press Enter to exit..." "$COLOR_PROMPT"
+        read -r
+    fi
+
+    if [ "$success" = true ]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+# Initialize backup behavior - backup is enabled by default unless NoBackup is specified
+if [ "$NO_BACKUP" = false ]; then
+    BACKUP_ALL=true
+fi
+
+# Parse command line arguments
+parse_arguments "$@"
+
+# Run main function
+main
+exit $?

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-v2.1.0--experimental-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)
@@ -13,418 +13,319 @@
 
 ---
 
-## 📋 Overview
+**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.
 
-**Claude Code Workflow (CCW)** is a next-generation multi-agent automation framework for software development that orchestrates complex development tasks through intelligent workflow management and autonomous execution.
-
-> **🧪 Latest Release v2.1.0-experimental**: Introduces **experimental MCP (Model Context Protocol) tools integration** for enhanced codebase analysis and external context retrieval. Includes Exa MCP Server for external API patterns and Code Index MCP for advanced internal codebase exploration. See [CHANGELOG.md](CHANGELOG.md) for details.
-
-> **⚠️ Experimental Features**: MCP tools are optional and experimental. All existing functionality remains stable.
-
-### 🌟 Key Innovations
-
-- **🔄 Enhanced Workflow Lifecycle**: Complete development cycle: Brainstorm → Plan → Verify → Execute → Test → Review
-- **🧪 Automated Test Generation**: Comprehensive test workflow generation (`/workflow:test-gen`) with full coverage planning
-- **✅ Plan Verification System**: Pre-execution validation using dual Gemini/Codex analysis (`/workflow:plan-verify`)
-- **🎯 JSON-First Architecture**: Single source of truth with atomic session management
-- **💡 Brainstorm Artifacts**: Multi-perspective planning with synthesis and structured document generation
-- **🔧 MCP Tools Integration** *(Experimental)*: Enhanced codebase analysis through Model Context Protocol tools
+> **🎉 Latest: v3.3.0** - CLI tool enhancements & Codex multi-step execution. See [CHANGELOG.md](CHANGELOG.md) for details.
+>
+> **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
 
 ---
 
-## 🏗️ System Architecture
+## ✨ Key Features
 
-### **🔧 Core Architectural Principles**
-
-```mermaid
-graph TB
-    subgraph "🖥️ CLI Interface Layer"
-        CLI[CLI Commands]
-        GEM[Gemini CLI]
-        COD[Codex CLI]
-        WRAPPER[Intelligent Gemini Wrapper]
-    end
-
-    subgraph "📋 Session Management"
-        MARKER[".active-session markers"]
-        SESSION["workflow-session.json"]
-        WDIR[".workflow/ directories"]
-    end
-
-    subgraph "📊 JSON-First Task System"
-        TASK_JSON[".task/impl-*.json"]
-        HIERARCHY["Task Hierarchy (max 2 levels)"]
-        STATUS["Task Status Management"]
-        DECOMP["Task Decomposition Engine"]
-    end
-
-    subgraph "🤖 Multi-Agent Orchestration"
-        PLAN_AGENT[Conceptual Planning Agent]
-        ACTION_AGENT[Action Planning Agent]
-        CODE_AGENT[Code Developer Agent]
-        REVIEW_AGENT[Code Review Agent]
-        MEMORY_AGENT[Memory Gemini Bridge]
-    end
-
-    CLI --> WRAPPER
-    WRAPPER --> GEM
-    CLI --> COD
-
-    GEM --> PLAN_AGENT
-    COD --> CODE_AGENT
-
-    PLAN_AGENT --> TASK_JSON
-    ACTION_AGENT --> TASK_JSON
-    CODE_AGENT --> TASK_JSON
-
-    TASK_JSON --> DECOMP
-    DECOMP --> HIERARCHY
-    HIERARCHY --> STATUS
-
-    SESSION --> MARKER
-    MARKER --> WDIR
-```
-
-### 🏛️ **Four-Layer Architecture**
-
-CCW 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 |
+- **🎯 Context-First Architecture**: Pre-defined context gathering eliminates execution uncertainty and error accumulation.
+- **🤖 Multi-Agent System**: Specialized agents (`@code-developer`, `@test-fix-agent`) with tech-stack awareness and automated test validation.
+- **🔄 End-to-End Workflow Automation**: From brainstorming to deployment with multi-phase orchestration.
+- **📋 JSON-First Task Model**: Structured task definitions with `pre_analysis` steps for deterministic execution.
+- **🧪 TDD Workflow Support**: Complete Test-Driven Development with Red-Green-Refactor cycle enforcement.
+- **🧠 Multi-Model Orchestration**: Leverages Gemini (analysis), Qwen (architecture), and Codex (implementation) strengths.
+- **✅ Pre-execution Verification**: Validates plans with both strategic (Gemini) and technical (Codex) analysis.
+- **🔧 Unified CLI**: A single, powerful `/cli:*` command set for interacting with various AI tools.
+- **📦 Smart Context Package**: `context-package.json` links tasks to relevant codebase files and external examples.
 
 ---
 
-## ✨ Major Enhancements v2.0
+## ⚙️ Installation
 
-### 🔄 **Enhanced Workflow Lifecycle**
-Complete development lifecycle with quality gates at each phase:
+### **🚀 Quick One-Line Installation**
 
-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
-
----
-
-## 📊 Complexity Management System
-
-CCW automatically adapts workflow structure based on project complexity:
-
-| **Complexity** | **Task Count** | **Structure** | **Features** |
-|---|---|---|---|
-| 🟢 **Simple** | <5 tasks | Single-level | Minimal overhead, direct execution |
-| 🟡 **Medium** | 5-10 tasks | Two-level hierarchy | Progress tracking, automated docs |
-| 🔴 **Complex** | >10 tasks | Force re-scoping | Multi-iteration planning required |
-
----
-
-## 🛠️ Complete Command Reference
-
-### 🎮 **Core System Commands**
-
-| Command | Function | Example |
-|---------|----------|---------|
-| `🎯 /enhance-prompt` | Technical context enhancement | `/enhance-prompt "add auth system"` |
-| `📊 /context` | Unified context management | `/context --analyze --format=tree` |
-| `📝 /update-memory-full` | Complete documentation update | `/update-memory-full` |
-| `🔄 /update-memory-related` | Smart context-aware updates | `/update-memory-related` |
-
-### 🔍 **Gemini CLI Commands** (Analysis & Investigation)
-
-| Command | Purpose | Usage |
-|---------|---------|-------|
-| `🔍 /gemini:analyze` | Deep codebase analysis | `/gemini:analyze "authentication patterns"` |
-| `💬 /gemini:chat` | Direct Gemini interaction | `/gemini:chat "explain this architecture"` |
-| `⚡ /gemini:execute` | Intelligent execution with YOLO permissions | `/gemini:execute "implement task-001"` |
-| `🎯 /gemini:mode:auto` | Auto template selection | `/gemini:mode:auto "analyze security vulnerabilities"` |
-| `🐛 /gemini:mode:bug-index` | Bug analysis and fix suggestions | `/gemini:mode:bug-index "payment processing fails"` |
-| `📋 /gemini:mode:plan` | Project planning and architecture | `/gemini:mode:plan "microservices architecture"` |
-| `🎯 /gemini:mode:plan-precise` | Precise path planning analysis | `/gemini:mode:plan-precise "complex refactoring"` |
-
-### 🔮 **Qwen CLI Commands** (Architecture & Code Generation)
-
-| Command | Purpose | Usage |
-|---------|---------|-------|
-| `🔍 /qwen:analyze` | Architecture analysis and code quality | `/qwen:analyze "system architecture patterns"` |
-| `💬 /qwen:chat` | Direct Qwen interaction | `/qwen:chat "design authentication system"` |
-| `⚡ /qwen:execute` | Intelligent implementation with YOLO permissions | `/qwen:execute "implement user authentication"` |
-| `🚀 /qwen:mode:auto` | Auto template selection and execution | `/qwen:mode:auto "build microservices API"` |
-| `🐛 /qwen:mode:bug-index` | Bug analysis and fix suggestions | `/qwen:mode:bug-index "memory leak in service"` |
-| `📋 /qwen:mode:plan` | Architecture planning and analysis | `/qwen:mode:plan "design scalable database"` |
-| `🎯 /qwen:mode:plan-precise` | Precise architectural planning | `/qwen:mode:plan-precise "complex system migration"` |
-
-### 🤖 **Codex CLI Commands** (Development & Implementation)
-
-| Command | Purpose | Usage |
-|---------|---------|-------|
-| `🔍 /codex:analyze` | Development analysis | `/codex:analyze "optimization opportunities"` |
-| `💬 /codex:chat` | Direct Codex interaction | `/codex:chat "implement JWT auth"` |
-| `⚡ /codex:execute` | Autonomous implementation with YOLO permissions | `/codex:execute "refactor user service"` |
-| `🚀 /codex:mode:auto` | **PRIMARY**: Full autonomous development | `/codex:mode:auto "build payment system"` |
-| `🐛 /codex:mode:bug-index` | Autonomous bug fixing and implementation | `/codex:mode:bug-index "fix race condition"` |
-| `📋 /codex:mode:plan` | Development planning and implementation | `/codex:mode:plan "implement API endpoints"` |
-
-### 🎯 **Workflow Management**
-
-#### 📋 Session Management
-| Command | Function | Usage |
-|---------|----------|-------|
-| `🚀 /workflow:session:start` | Create new session | `/workflow:session:start "OAuth2 System"` |
-| `⏸️ /workflow:session:pause` | Pause current session | `/workflow:session:pause` |
-| `▶️ /workflow:session:resume` | Resume session | `/workflow:session:resume "OAuth2 System"` |
-| `📋 /workflow:session:list` | List all sessions | `/workflow:session:list --active` |
-| `🔄 /workflow:session:switch` | Switch sessions | `/workflow:session:switch "Payment Fix"` |
-
-#### 🎯 Workflow Operations
-| Command | Function | Usage |
-|---------|----------|-------|
-| `💭 /workflow:brainstorm:*` | Multi-perspective planning with role experts | `/workflow:brainstorm:system-architect "microservices"` |
-| `🤝 /workflow:brainstorm:synthesis` | Synthesize all brainstorming perspectives | `/workflow:brainstorm:synthesis` |
-| `🎨 /workflow:brainstorm:artifacts` | Generate structured planning documents | `/workflow:brainstorm:artifacts "topic description"` |
-| `📋 /workflow:plan` | Convert to executable implementation plans | `/workflow:plan "description" \| file.md \| ISS-001` |
-| `🔍 /workflow:plan-deep` | Deep technical planning with Gemini analysis | `/workflow:plan-deep "requirements description"` |
-| `✅ /workflow:plan-verify` | Pre-execution validation using dual analysis | `/workflow:plan-verify` |
-| `⚡ /workflow:execute` | Coordinate agents for implementation | `/workflow:execute` |
-| `🔄 /workflow:resume` | Intelligent workflow resumption | `/workflow:resume [--from TASK-ID] [--retry]` |
-| `📊 /workflow:status` | Generate on-demand views from task data | `/workflow:status [task-id] [format] [validation]` |
-| `🧪 /workflow:test-gen` | Generate comprehensive test workflows | `/workflow:test-gen WFS-session-id` |
-| `🔍 /workflow:review` | Execute review phase for quality validation | `/workflow:review` |
-| `📚 /workflow:docs` | Generate hierarchical documentation | `/workflow:docs "architecture" \| "api" \| "all"` |
-
-#### 🏷️ Task Management
-| Command | Function | Usage |
-|---------|----------|-------|
-| `➕ /task:create` | Create implementation task with context | `/task:create "User Authentication System"` |
-| `🔄 /task:breakdown` | Intelligent task decomposition | `/task:breakdown task-id` |
-| `⚡ /task:execute` | Execute tasks with appropriate agents | `/task:execute task-id` |
-| `📋 /task:replan` | Replan tasks with detailed input | `/task:replan task-id ["text" \| file.md \| ISS-001]` |
-
-#### 🏷️ Issue Management
-| Command | Function | Usage |
-|---------|----------|-------|
-| `➕ /workflow:issue:create` | Create new project issue | `/workflow:issue:create "API Rate Limiting" --priority=high` |
-| `📋 /workflow:issue:list` | List and filter issues | `/workflow:issue:list --status=open --assigned=system-architect` |
-| `📝 /workflow:issue:update` | Update existing issue | `/workflow:issue:update ISS-001 --status=in-progress` |
-| `✅ /workflow:issue:close` | Close completed issue | `/workflow:issue:close ISS-001 --reason=resolved` |
-
-#### 🧠 Brainstorming Role Commands
-| Role | Command | Purpose |
-|------|---------|---------|
-| 🏗️ **System Architect** | `/workflow:brainstorm:system-architect` | Technical architecture analysis |
-| 🔒 **Security Expert** | `/workflow:brainstorm:security-expert` | Security and threat analysis |
-| 📊 **Product Manager** | `/workflow:brainstorm:product-manager` | User needs and business value |
-| 🎨 **UI Designer** | `/workflow:brainstorm:ui-designer` | User experience and interface |
-| 📈 **Business Analyst** | `/workflow:brainstorm:business-analyst` | Process optimization analysis |
-| 🔬 **Innovation Lead** | `/workflow:brainstorm:innovation-lead` | Emerging technology opportunities |
-| 📋 **Feature Planner** | `/workflow:brainstorm:feature-planner` | Feature development planning |
-| 🗄️ **Data Architect** | `/workflow:brainstorm:data-architect` | Data modeling and analytics |
-| 👥 **User Researcher** | `/workflow:brainstorm:user-researcher` | User behavior analysis |
-| 🚀 **Auto Selection** | `/workflow:brainstorm:auto` | Dynamic role selection |
-
----
-
-## 🎯 Complete Development Workflows
-
-### 🚀 **Enhanced Workflow Lifecycle**
-
-```mermaid
-graph TD
-    START[🎯 New Feature Request] --> SESSION["/workflow:session:start 'OAuth2 System'"]
-    SESSION --> BRAINSTORM["/workflow:brainstorm:system-architect topic"]
-    BRAINSTORM --> SYNTHESIS["/workflow:brainstorm:synthesis"]
-    SYNTHESIS --> PLAN["/workflow:plan description"]
-    PLAN --> VERIFY["/workflow:plan-verify"]
-    VERIFY --> EXECUTE["/workflow:execute"]
-    EXECUTE --> TEST["/workflow:test-gen WFS-session-id"]
-    TEST --> REVIEW["/workflow:review"]
-    REVIEW --> DOCS["/workflow:docs all"]
-    DOCS --> COMPLETE[✅ Complete]
-```
-
-### ⚡ **Workflow Session Management**
-
-```mermaid
-graph LR
-    START[📋 Session Start] --> MARKER[🏷️ .active-session marker]
-    MARKER --> JSON[📊 workflow-session.json]
-    JSON --> TASKS[🎯 .task/IMPL-*.json]
-    TASKS --> PAUSE[⏸️ Pause: Remove marker]
-    PAUSE --> RESUME[▶️ Resume: Restore marker]
-    RESUME --> SWITCH[🔄 Switch: Change active session]
-```
-
-### 🔥 **Quick Development Examples**
-
-#### **🚀 Complete Feature Development Workflow**
-```bash
-# 1. Initialize focused session
-/workflow:session:start "User Dashboard Feature"
-
-# 2. Multi-perspective brainstorming
-/workflow:brainstorm:system-architect "dashboard analytics system"
-/workflow:brainstorm:ui-designer "dashboard user experience"
-/workflow:brainstorm:data-architect "analytics data flow"
-
-# 3. Synthesize all perspectives
-/workflow:brainstorm:synthesis
-
-# 4. Create executable implementation plan
-/workflow:plan "user dashboard with analytics and real-time data"
-
-# 5. Verify plan before execution
-/workflow:plan-verify
-
-# 6. Execute implementation with agent coordination
-/workflow:execute
-
-# 7. Generate comprehensive test suite
-/workflow:test-gen WFS-user-dashboard-feature
-
-# 8. Quality assurance and review
-/workflow:review
-
-# 9. Generate documentation
-/workflow:docs "all"
-```
-
-#### **⚡ Rapid Bug Resolution**
-```bash
-# Quick bug fix workflow
-/workflow:session:start "Payment Processing Fix"
-/gemini:mode:bug-index "Payment validation fails on concurrent requests"
-/codex:mode:bug-index "Fix race condition in payment validation"
-/workflow:review
-```
-
-#### **📊 Architecture Analysis & Refactoring**
-```bash
-# Deep architecture workflow
-/workflow:session:start "API Refactoring Initiative"
-/gemini:analyze "current API architecture patterns and technical debt"
-/workflow:plan-deep "microservices transition strategy"
-/workflow:plan-verify
-/qwen:mode:auto "Refactor monolith to microservices architecture"
-/workflow:test-gen WFS-api-refactoring-initiative
-/workflow:review
-```
-
----
-
-## 🏗️ Project Structure
-
-```
-📁 .claude/
-├── 🤖 agents/                 # AI agent definitions
-├── 🎯 commands/              # CLI command implementations
-│   ├── 🔍 gemini/           # Gemini CLI commands
-│   ├── 🤖 codex/            # Codex CLI commands
-│   └── 🎯 workflow/         # Workflow management
-├── 🎨 output-styles/         # Output formatting templates
-├── 🎭 planning-templates/    # Role-specific planning
-├── 💬 prompt-templates/      # AI interaction templates
-├── 🔧 scripts/              # Automation utilities
-│   ├── 📊 gemini-wrapper           # Intelligent Gemini wrapper
-│   ├── 🔧 get_modules_by_depth.sh  # Project analysis
-│   └── 📋 read-task-paths.sh       # Task path conversion
-├── 🛠️ workflows/            # Core workflow documentation
-│   ├── 🏛️ workflow-architecture.md      # System architecture
-│   ├── 📊 intelligent-tools-strategy.md # Tool selection guide
-│   ├── 🔧 context-search-strategy.md  # Search and discovery strategy
-│   └── 🔧 tools-implementation-guide.md # Implementation details
-└── ⚙️ settings.local.json   # Local configuration
-
-📁 .workflow/                 # Session workspace (auto-generated)
-├── 🏷️ .active-[session]     # Active session markers
-└── 📋 WFS-[topic-slug]/      # Individual sessions
-    ├── ⚙️ workflow-session.json    # Session metadata
-    ├── 📊 .task/impl-*.json        # Task definitions
-    ├── 📝 IMPL_PLAN.md             # Planning documents
-    ├── ✅ TODO_LIST.md              # Progress tracking
-    ├── 📚 .summaries/              # Completion summaries
-    ├── 🧠 .process/                # NEW: Planning artifacts
-    │   └── 📈 ANALYSIS_RESULTS.md  # Analysis results
-    └── 🧪 WFS-test-[session]/     # NEW: Generated test workflows
-```
-
----
-
-## ⚡ Performance & Technical Specs
-
-### 📊 **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
-- **🎯 Claude Code IDE**: Recommended for optimal experience
-
----
-
-## ⚙️ Installation & Configuration
-
-### 🚀 **Quick Installation**
+**Windows (PowerShell):**
 ```powershell
 Invoke-Expression (Invoke-WebRequest -Uri "https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.ps1" -UseBasicParsing).Content
 ```
 
-### ✅ **Verify Installation**
+**Linux/macOS (Bash/Zsh):**
+```bash
+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
 ```
 
-### ⚙️ **Essential Configuration**
+> **📝 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
+
+### Complete Development Workflow
+
+**Phase 1: Brainstorming & Conceptual Planning**
+```bash
+# Multi-perspective brainstorming with role-based agents
+/workflow:brainstorm:auto-parallel "Build a user authentication system"
+
+# Review and refine specific aspects (optional)
+/workflow:brainstorm:ui-designer "authentication flows"
+/workflow:brainstorm:synthesis  # Generate consolidated specification
+```
+
+**Phase 2: Action Planning**
+```bash
+# Create executable implementation plan
+/workflow:plan "Implement JWT-based authentication system"
+
+# OR for TDD approach
+/workflow:tdd-plan "Implement authentication with test-first development"
+```
+
+**Phase 3: Execution**
+```bash
+# Execute tasks with AI agents
+/workflow:execute
+
+# Monitor progress
+/workflow:status
+```
+
+**Phase 4: Testing & Quality Assurance**
+```bash
+# Generate independent test-fix workflow (v3.2.2+)
+/workflow:test-gen WFS-auth  # Creates WFS-test-auth session
+/workflow:execute            # Runs test validation
+
+# OR verify TDD compliance (TDD workflow)
+/workflow:tdd-verify
+```
+
+### Quick Start for Simple Tasks
+
+**Feature Development:**
+```bash
+/workflow:session:start "Add password reset feature"
+/workflow:plan "Email-based password reset with token expiry"
+/workflow:execute
+```
+
+**Bug Fixing:**
+```bash
+# Interactive analysis with CLI tools
+/cli:mode:bug-index --tool gemini "Login timeout on mobile devices"
+
+# Execute the suggested fix
+/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
+/cli:mode:code-analysis --tool qwen "Analyze authentication module architecture"
+```
+
+---
+
+## 🛠️ Command Reference
+
+### **Unified CLI Commands (`/cli:*)**
+*Use the `--tool <gemini|qwen|codex>` flag to select the desired tool. Defaults to `gemini`.*
+
+| Command | Description |
+|---|---|
+| `/cli:analyze` | Deep codebase analysis. |
+| `/cli:chat` | Direct, interactive chat with a tool. |
+| `/cli:execute` | Execute a task with full permissions. |
+| `/cli:cli-init`| Initialize CLI tool configurations for the workspace. |
+| `/cli:mode:bug-index` | Analyze bugs and suggest fixes. |
+| `/cli:mode:code-analysis` | Perform deep code analysis and debugging. |
+| `/cli:mode:plan` | Project planning and architecture analysis. |
+
+### **Workflow Commands (`/workflow:*)**
+
+| Command | Description |
+|---|---|
+| `/workflow:session:*` | Manage development sessions (`start`, `pause`, `resume`, `list`, `switch`, `complete`). |
+| `/workflow:brainstorm:*` | Use role-based agents for multi-perspective planning. |
+| `/workflow:plan` | Create a detailed, executable plan from a description. |
+| `/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` | 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). |
+
+### **Task & Memory Commands**
+
+| Command | Description |
+|---|---|
+| `/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:
 
-#### **Gemini CLI Setup**
 ```json
 // ~/.gemini/settings.json
 {
-  "contextFileName": "CLAUDE.md"
+  "contextFileName": ["CLAUDE.md", "GEMINI.md"]
 }
 ```
 
-#### **Optimized .geminiignore**
+### **Recommended: .geminiignore**
+
+Optimize performance by excluding unnecessary files:
+
 ```bash
-# Performance optimization
+# .geminiignore (in project root)
 /dist/
 /build/
 /node_modules/
 /.next/
-
-# Temporary files
 *.tmp
 *.log
 /temp/
@@ -434,89 +335,187 @@ Invoke-Expression (Invoke-WebRequest -Uri "https://raw.githubusercontent.com/cat
 !**/CLAUDE.md
 ```
 
-### 🔧 **MCP Tools Configuration** *(Optional Enhancement)*
+### **Optional: MCP Tools** *(Enhanced Analysis)*
 
-[![MCP Tools](https://img.shields.io/badge/🔧_MCP_Tools-Optional-blue.svg)](https://github.com/modelcontextprotocol)
+MCP (Model Context Protocol) tools provide advanced codebase analysis. **Completely optional** - CCW works perfectly without them.
 
-**MCP (Model Context Protocol) tools provide enhanced codebase analysis capabilities. They are completely optional - CCW works perfectly without them.**
+#### Available MCP Servers
 
-#### **Quick MCP Setup**
-1. **Install MCP Servers** (choose what you need):
-   ```bash
-   # Option 1: Exa MCP Server (External API patterns)
-   # 📋 Installation Guide: https://github.com/exa-labs/exa-mcp-server
+| MCP Server | Purpose | Installation Guide |
+|------------|---------|-------------------|
+| **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) |
 
-   # Option 2: Code Index MCP (Advanced code search)
-   # 📋 Installation Guide: https://github.com/johnhuang316/code-index-mcp
-   ```
-
-2. **Configure Claude Code IDE**:
-   - Follow the MCP server installation guides above
-   - Restart Claude Code IDE after MCP server installation
-   - CCW will automatically detect and use available MCP tools
-
-#### **Benefits When Enabled**
+#### Benefits When Enabled
 - 📊 **Faster Analysis**: Direct codebase indexing vs manual searching
 - 🌐 **External Context**: Real-world API patterns and examples
 - 🔍 **Advanced Search**: Pattern matching and similarity detection
 - ⚡ **Automatic Fallback**: Uses traditional tools when MCP unavailable
 
-#### **Configuration Resources**
-| MCP Server | Installation Guide | Purpose |
-|------------|-------------------|---------|
-| 🌐 **Exa MCP** | [Installation Guide](https://github.com/exa-labs/exa-mcp-server) | External API patterns & best practices |
-| 🔍 **Code Index MCP** | [Installation Guide](https://github.com/johnhuang316/code-index-mcp) | Advanced internal codebase search |
-| 📖 **MCP Protocol** | [Official Documentation](https://github.com/modelcontextprotocol) | Technical specifications |
+---
 
-> **💡 Pro Tip**: Start with basic CCW functionality, then add MCP tools when you want enhanced analysis capabilities.
+## 🧩 How It Works: Design Philosophy
+
+### The Core Problem
+
+Traditional AI coding workflows face a fundamental challenge: **execution uncertainty leads to error accumulation**.
+
+**Example:**
+```bash
+# Prompt 1: "Develop XX feature"
+# Prompt 2: "Review XX architecture in file Y, then develop XX feature"
+```
+
+While Prompt 1 might succeed for simple tasks, in complex workflows:
+- The AI may examine different files each time
+- Small deviations compound across multiple steps
+- Final output drifts from the intended goal
+
+> **CCW's Mission**: Solve the "1-to-N" problem — building upon existing codebases with precision, not just "0-to-1" greenfield development.
 
 ---
 
-## 🤝 Contributing
+### The CCW Solution: Context-First Architecture
 
-### 🛠️ **Development Setup**
-1. 🍴 Fork the repository
-2. 🌿 Create feature branch: `git checkout -b feature/enhancement-name`
-3. 📦 Install dependencies
-4. ✅ Test with sample projects
-5. 📤 Submit detailed pull request
+#### 1. **Pre-defined Context Gathering**
 
-### 📏 **Code Standards**
-- ✅ Follow existing command patterns
-- 🔄 Maintain backward compatibility
-- 🧪 Add tests for new functionality
-- 📚 Update documentation
-- 🏷️ Use semantic versioning
+Instead of letting agents randomly explore, CCW uses structured context packages:
+
+**`context-package.json`** created during planning:
+```json
+{
+  "metadata": {
+    "task_description": "...",
+    "tech_stack": {"frontend": [...], "backend": [...]},
+    "complexity": "high"
+  },
+  "assets": [
+    {
+      "path": "synthesis-specification.md",
+      "priority": "critical",
+      "sections": ["Backend Module Structure"]
+    }
+  ],
+  "implementation_guidance": {
+    "start_with": ["Step 1", "Step 2"],
+    "critical_security_items": [...]
+  }
+}
+```
+
+#### 2. **JSON-First Task Model**
+
+Each task includes a `flow_control.pre_analysis` section:
+
+```json
+{
+  "id": "IMPL-1",
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "load_architecture",
+        "commands": ["Read(architecture.md)", "grep 'auth' src/"],
+        "output_to": "arch_context",
+        "on_error": "fail"
+      }
+    ],
+    "implementation_approach": {
+      "modification_points": ["..."],
+      "logic_flow": ["..."]
+    },
+    "target_files": ["src/auth/index.ts"]
+  }
+}
+```
+
+**Key Innovation**: The `pre_analysis` steps are **executed before implementation**, ensuring agents always have the correct context.
+
+#### 3. **Multi-Phase Orchestration**
+
+CCW workflows are orchestrators that coordinate slash commands:
+
+**Planning Phase** (`/workflow:plan`):
+```
+Phase 1: session:start       → Create session
+Phase 2: context-gather      → Build context-package.json
+Phase 3: concept-enhanced    → CLI analysis (Gemini/Qwen)
+Phase 4: task-generate       → Generate task JSONs with pre_analysis
+```
+
+**Execution Phase** (`/workflow:execute`):
+```
+For each task:
+  1. Execute pre_analysis steps → Load context
+  2. Apply implementation_approach → Make changes
+  3. Validate acceptance criteria → Verify success
+  4. Generate summary → Track progress
+```
+
+#### 4. **Multi-Model Orchestration**
+
+Each AI model serves its strength:
+
+| Model | Role | Use Cases |
+|-------|------|-----------|
+| **Gemini** | Analysis & Understanding | Long-context analysis, architecture review, bug investigation |
+| **Qwen** | Architecture & Design | System design, code generation, architectural planning |
+| **Codex** | Implementation | Feature development, testing, autonomous execution |
+
+**Example:**
+```bash
+# Gemini analyzes the problem space
+/cli:mode:code-analysis --tool gemini "Analyze auth module"
+
+# Qwen designs the solution
+/cli:analyze --tool qwen "Design scalable auth architecture"
+
+# Codex implements the code
+/workflow:execute  # Uses @code-developer with Codex
+```
 
 ---
 
-## 📞 Support & Resources
+### From 0-to-1 vs 1-to-N Development
 
-<div align="center">
-
-| Resource | Link | Description |
-|----------|------|-------------|
-| 📚 **Documentation** | [Project Wiki](https://github.com/catlog22/Claude-Code-Workflow/wiki) | Comprehensive guides |
-| 🐛 **Issues** | [GitHub Issues](https://github.com/catlog22/Claude-Code-Workflow/issues) | Bug reports & features |
-| 💬 **Discussions** | [Community Forum](https://github.com/catlog22/Claude-Code-Workflow/discussions) | Community support |
-| 📋 **Changelog** | [Release History](CHANGELOG.md) | Version history |
-
-</div>
+| Scenario | Traditional Workflow | CCW Approach |
+|----------|---------------------|--------------|
+| **Greenfield (0→1)** | ✅ Works well | ✅ Adds structured planning |
+| **Feature Addition (1→2)** | ⚠️ Context uncertainty | ✅ Context-package links to existing code |
+| **Bug Fixing (N→N+1)** | ⚠️ May miss related code | ✅ Pre-analysis finds dependencies |
+| **Refactoring** | ⚠️ Unpredictable scope | ✅ CLI analysis + structured tasks |
 
 ---
 
+### Key Workflows
+
+#### **Complete Development (Brainstorm → Deploy)**
+```
+Brainstorm (8 roles) → Synthesis → Plan (4 phases) → Execute → Test → Review
+```
+
+#### **Quick Feature Development**
+```
+session:start → plan → execute → test-gen → execute
+```
+
+#### **TDD Workflow**
+```
+tdd-plan (TEST→IMPL→REFACTOR chains) → execute → tdd-verify
+```
+
+#### **Bug Fixing**
+```
+cli:mode:bug-index (analyze) → execute (fix) → test-gen (verify)
+```
+
+---
+
+## 🤝 Contributing & Support
+
+- **Repository**: [GitHub - Claude-Code-Workflow](https://github.com/catlog22/Claude-Code-Workflow)
+- **Issues**: Report bugs or request features on [GitHub Issues](https://github.com/catlog22/Claude-Code-Workflow/issues).
+- **Discussions**: Join the [Community Forum](https://github.com/catlog22/Claude-Code-Workflow/discussions).
+
 ## 📄 License
 
-This project is licensed under the **MIT License** - see the [LICENSE](LICENSE) file for details.
-
----
-
-<div align="center">
-
-**🚀 Claude Code Workflow (CCW)**
-
-*Professional software development workflow automation through intelligent multi-agent coordination and autonomous execution capabilities.*
-
-[![⭐ Star on GitHub](https://img.shields.io/badge/⭐-Star%20on%20GitHub-yellow.svg)](https://github.com/catlog22/Claude-Code-Workflow)
-
-</div>
+This project is licensed under the **MIT License**. See the [LICENSE](LICENSE) file for details.

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-Host "- This script will download and execute Claude Code Workflow from GitHub"
-        Write-Host "- Repository: https://github.com/catlog22/Claude-Code-Workflow"  
-        Write-Host "- Branch: $Branch (latest stable version)"
+        Write-ColorOutput "INSTALLATION DETAILS:" $ColorInfo
+        Write-Host "- Repository: https://github.com/catlog22/Claude-Code-Workflow"
+        Write-Host "- Version: $versionInfo"
         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
-        $success = Invoke-LocalInstaller $repoDir
+
+        # Determine version and branch information to pass
+        $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

@@ -0,0 +1,672 @@
+#!/usr/bin/env bash
+# Claude Code Workflow (CCW) - Remote Installation Script
+# One-liner remote installation for Claude Code Workflow system
+
+set -e  # Exit on error
+
+# Script metadata
+SCRIPT_NAME="Claude Code Workflow (CCW) Remote Installer"
+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'
+COLOR_INFO='\033[0;36m'
+COLOR_WARNING='\033[0;33m'
+COLOR_ERROR='\033[0;31m'
+
+# Variables
+INSTALL_GLOBAL=false
+INSTALL_DIR=""
+FORCE=false
+NO_BACKUP=false
+NON_INTERACTIVE=false
+BACKUP_ALL=false
+
+# Functions
+function write_color() {
+    local message="$1"
+    local color="${2:-$COLOR_RESET}"
+    echo -e "${color}${message}${COLOR_RESET}"
+}
+
+function show_header() {
+    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 2 ]; then
+        write_color "ERROR: Bash 2.0 or higher is required" "$COLOR_ERROR"
+        write_color "Current version: ${BASH_VERSION}" "$COLOR_ERROR"
+        return 1
+    fi
+
+    # Test required commands
+    for cmd in curl unzip; do
+        if ! command -v "$cmd" &> /dev/null; then
+            write_color "ERROR: Required command '$cmd' not found" "$COLOR_ERROR"
+            write_color "Please install: $cmd" "$COLOR_ERROR"
+            return 1
+        fi
+    done
+
+    # Test internet connectivity
+    if curl -sSf --connect-timeout 10 "https://github.com" &> /dev/null; then
+        write_color "✓ Network connection OK" "$COLOR_SUCCESS"
+    else
+        write_color "ERROR: Cannot connect to GitHub" "$COLOR_ERROR"
+        write_color "Please check your network connection" "$COLOR_ERROR"
+        return 1
+    fi
+
+    return 0
+}
+
+function get_temp_directory() {
+    local temp_dir
+    temp_dir=$(mktemp -d -t claude-code-workflow-install.XXXXXX)
+    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 version_type="${2:-stable}"
+    local branch="${3:-main}"
+    local tag="${4:-}"
+    local repo_url="https://github.com/catlog22/Claude-Code-Workflow"
+    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 "Type: $download_type" "$COLOR_INFO" >&2
+
+    # Download with curl
+    if curl -fsSL -o "$zip_path" "$zip_url" 2>&1 >&2; then
+        # Verify the download
+        if [ -f "$zip_path" ]; then
+            local file_size
+            file_size=$(du -h "$zip_path" 2>/dev/null | cut -f1)
+            write_color "✓ Download complete ($file_size)" "$COLOR_SUCCESS" >&2
+
+            # Output path to stdout for capture
+            echo "$zip_path"
+            return 0
+        else
+            write_color "ERROR: Downloaded file does not exist" "$COLOR_ERROR" >&2
+            return 1
+        fi
+    else
+        write_color "ERROR: Download failed" "$COLOR_ERROR" >&2
+        return 1
+    fi
+}
+
+function extract_repository() {
+    local zip_path="$1"
+    local temp_dir="$2"
+
+    write_color "Extracting files..." "$COLOR_INFO" >&2
+
+    # Verify zip file exists
+    if [ ! -f "$zip_path" ]; then
+        write_color "ERROR: ZIP file not found: $zip_path" "$COLOR_ERROR" >&2
+        return 1
+    fi
+
+    # Extract with unzip
+    if unzip -q "$zip_path" -d "$temp_dir" >&2 2>&1; then
+        # Find the extracted directory
+        local repo_dir
+        repo_dir=$(find "$temp_dir" -maxdepth 1 -type d -name "Claude-Code-Workflow-*" 2>/dev/null | head -n 1)
+
+        if [ -n "$repo_dir" ] && [ -d "$repo_dir" ]; then
+            write_color "✓ Extraction complete: $repo_dir" "$COLOR_SUCCESS" >&2
+            # Output path to stdout for capture
+            echo "$repo_dir"
+            return 0
+        else
+            write_color "ERROR: Could not find extracted repository directory" "$COLOR_ERROR" >&2
+            write_color "Temp directory contents:" "$COLOR_INFO" >&2
+            ls -la "$temp_dir" >&2
+            return 1
+        fi
+    else
+        write_color "ERROR: Extraction failed" "$COLOR_ERROR" >&2
+        return 1
+    fi
+}
+
+function invoke_local_installer() {
+    local repo_dir="$1"
+    local installer_path="${repo_dir}/Install-Claude.sh"
+
+    # Make installer executable
+    if [ -f "$installer_path" ]; then
+        chmod +x "$installer_path"
+    else
+        write_color "ERROR: Install-Claude.sh not found" "$COLOR_ERROR"
+        return 1
+    fi
+
+    write_color "Running local installer..." "$COLOR_INFO"
+    echo ""
+
+    # Build parameters for local installer
+    local params=()
+
+    if [ "$INSTALL_GLOBAL" = true ]; then
+        params+=("-InstallMode" "Global")
+    fi
+
+    if [ -n "$INSTALL_DIR" ]; then
+        params+=("-InstallMode" "Path" "-TargetPath" "$INSTALL_DIR")
+    fi
+
+    if [ "$FORCE" = true ]; then
+        params+=("-Force")
+    fi
+
+    if [ "$NO_BACKUP" = true ]; then
+        params+=("-NoBackup")
+    fi
+
+    if [ "$NON_INTERACTIVE" = true ]; then
+        params+=("-NonInteractive")
+    fi
+
+    if [ "$BACKUP_ALL" = true ]; then
+        params+=("-BackupAll")
+    fi
+
+    # Execute installer
+    if (cd "$repo_dir" && "$installer_path" "${params[@]}"); then
+        return 0
+    else
+        write_color "Installation script failed" "$COLOR_ERROR"
+        return 1
+    fi
+}
+
+function cleanup_temp_files() {
+    local temp_dir="$1"
+
+    if [ -d "$temp_dir" ]; then
+        if rm -rf "$temp_dir"; then
+            write_color "✓ Temporary files cleaned up" "$COLOR_INFO"
+        else
+            write_color "WARNING: Failed to clean temporary files" "$COLOR_WARNING"
+        fi
+    fi
+}
+
+function wait_for_user() {
+    local message="${1:-Press Enter to continue...}"
+
+    if [ "$NON_INTERACTIVE" != true ]; then
+        echo ""
+        write_color "$message" "$COLOR_INFO"
+        read -r
+        echo ""
+    fi
+}
+
+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
+                ;;
+            --directory)
+                INSTALL_DIR="$2"
+                shift 2
+                ;;
+            --force)
+                FORCE=true
+                shift
+                ;;
+            --no-backup)
+                NO_BACKUP=true
+                shift
+                ;;
+            --non-interactive)
+                NON_INTERACTIVE=true
+                shift
+                ;;
+            --backup-all)
+                BACKUP_ALL=true
+                shift
+                ;;
+            --help)
+                show_help
+                exit 0
+                ;;
+            *)
+                write_color "Unknown option: $1" "$COLOR_ERROR"
+                show_help
+                exit 1
+                ;;
+        esac
+    done
+}
+
+function show_help() {
+    cat << EOF
+$SCRIPT_NAME v$INSTALLER_VERSION
+
+Usage: $0 [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
+    --help                Show this help message
+
+Examples:
+    # 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
+
+    write_color "This will download and install Claude Code Workflow System from GitHub." "$COLOR_INFO"
+    echo ""
+
+    # Test prerequisites
+    write_color "Checking system requirements..." "$COLOR_INFO"
+    if ! test_prerequisites; then
+        wait_for_user "System check failed! Press Enter to exit..."
+        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 "INSTALLATION DETAILS:" "$COLOR_INFO"
+        echo "- Repository: https://github.com/catlog22/Claude-Code-Workflow"
+        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 ""
+
+        read -p "Continue with installation? (y/N) " -r choice
+        if [[ ! $choice =~ ^[Yy]$ ]]; then
+            write_color "Installation cancelled" "$COLOR_WARNING"
+            exit 0
+        fi
+    fi
+
+    # Create temp directory
+    local temp_dir
+    temp_dir=$(get_temp_directory)
+    write_color "Temporary directory: $temp_dir" "$COLOR_INFO"
+
+    local success=false
+
+    # Download repository
+    local zip_path
+    write_color "Starting download process..." "$COLOR_INFO"
+    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
+        write_color "Download successful: $zip_path" "$COLOR_SUCCESS"
+
+        # Extract repository
+        local repo_dir
+        write_color "Starting extraction process..." "$COLOR_INFO"
+        repo_dir=$(extract_repository "$zip_path" "$temp_dir")
+        local extract_status=$?
+
+        if [ $extract_status -eq 0 ] && [ -n "$repo_dir" ] && [ -d "$repo_dir" ]; then
+            write_color "Extraction successful: $repo_dir" "$COLOR_SUCCESS"
+
+            # Run local installer
+            if invoke_local_installer "$repo_dir"; then
+                success=true
+                echo ""
+                write_color "✓ Remote installation completed successfully!" "$COLOR_SUCCESS"
+            else
+                write_color "ERROR: Installation script failed" "$COLOR_ERROR"
+            fi
+        else
+            write_color "ERROR: Extraction failed (status: $extract_status)" "$COLOR_ERROR"
+            if [ ! -f "$zip_path" ]; then
+                write_color "ZIP file does not exist: $zip_path" "$COLOR_ERROR"
+            elif [ ! -s "$zip_path" ]; then
+                write_color "ZIP file is empty: $zip_path" "$COLOR_ERROR"
+            fi
+        fi
+    else
+        write_color "ERROR: Download failed (status: $download_status)" "$COLOR_ERROR"
+        if [ -z "$zip_path" ]; then
+            write_color "Download did not return a file path" "$COLOR_ERROR"
+        elif [ ! -f "$zip_path" ]; then
+            write_color "Downloaded file does not exist: $zip_path" "$COLOR_ERROR"
+        fi
+    fi
+
+    # Cleanup
+    cleanup_temp_files "$temp_dir"
+
+    if [ "$success" = true ]; then
+        echo ""
+        write_color "Next steps:" "$COLOR_INFO"
+        echo "1. Review CLAUDE.md for project-specific guidelines"
+        echo "2. Try /workflow commands for Agent coordination"
+        echo "3. Use /update-memory to manage distributed documentation"
+
+        wait_for_user "Remote installation done! Press Enter to exit..."
+        exit 0
+    else
+        echo ""
+        wait_for_user "Installation failed! Press Enter to exit..."
+        exit 1
+    fi
+}
+
+# Parse command line arguments
+parse_arguments "$@"
+
+# Run main function
+main