feat: Implement Cross-CLI Sync Panel for MCP servers

- Added CrossCliSyncPanel component for synchronizing MCP servers between Claude and Codex.
- Implemented server selection, copy operations, and result handling.
- Added tests for path mapping on Windows drives.
- Created E2E tests for ask_question Answer Broker functionality.
- Introduced MCP Tools Test Script for validating modified read_file and edit_file tools.
- Updated path_mapper to ensure correct drive formatting on Windows.
- Added .gitignore for ace-tool directory.

.ccw/workflows/chinese-response.md

@@ -0,0 +1,25 @@
+# 中文回复准则
+
+## 核心原则
+
+- 所有回复使用简体中文
+- 技术术语保留英文，首次出现可添加中文解释
+- 代码变量名保持英文，注释使用中文
+
+## 格式规范
+
+- 中英文/数字间加空格：`使用 TypeScript 开发`、`共 3 个文件`
+- 使用中文标点：，。！？：；
+- 代码/命令用反引号：`npm install`
+
+## Git Commit
+
+- 使用中文提交信息
+- 格式：`类型: 简短描述`
+- 类型：feat/fix/refactor/docs/test/chore
+
+## 保持英文
+
+- 代码文件内容
+- 错误信息和日志
+- 文件路径和命令

.ccw/workflows/cli-templates/fix-plan-template.json

@@ -0,0 +1,75 @@
+{
+  "_template_description": "Template for fix planning output. Planning agent reads this template and generates actual fix-plan.json",
+  "_usage": "Planning agent should follow this structure when analyzing findings and creating fix plan",
+
+  "plan_id": "<string: plan-{timestamp}>",
+  "created_at": "<string: ISO8601 timestamp>",
+  "total_findings": "<number: total findings to fix>",
+
+  "execution_strategy": {
+    "approach": "<string: hybrid|parallel|serial>",
+    "parallel_limit": "<number: max concurrent agents, default 3>",
+    "total_stages": "<number: how many stages in timeline>",
+    "rationale": "<string: explain why this strategy was chosen>"
+  },
+
+  "groups": [
+    {
+      "group_id": "<string: unique group identifier like G1, G2, ...>",
+      "group_name": "<string: descriptive name for this group>",
+      "findings": ["<array of finding IDs>"],
+
+      "fix_strategy": {
+        "approach": "<string: high-level fix approach>",
+        "rationale": "<string: why these findings were grouped together>",
+        "complexity": "<string: low|medium|high>",
+        "estimated_duration_minutes": "<number: estimated time>",
+        "test_pattern": "<string: test file glob pattern like tests/auth/**/*.test.*>",
+        "rollback_plan": "<string: what to do if fix fails>"
+      },
+
+      "risk_assessment": {
+        "level": "<string: low|medium|high|critical>",
+        "concerns": ["<array of strings: potential risks>"],
+        "mitigation": "<string: how to mitigate risks>"
+      }
+    }
+  ],
+
+  "timeline": [
+    {
+      "stage": "<number: stage number 1-indexed>",
+      "groups": ["<array of group IDs to execute in this stage>"],
+      "execution_mode": "<string: parallel|serial>",
+      "depends_on": ["<optional: array of group IDs this stage depends on>"],
+      "rationale": "<string: why these groups are in this stage with this mode>"
+    }
+  ],
+
+  "_instructions": {
+    "grouping_principles": [
+      "Group findings in the same file with same dimension",
+      "Group findings with similar root causes (high semantic similarity)",
+      "Consider file dependencies and execution order",
+      "Balance group sizes for efficient parallel execution"
+    ],
+    "execution_strategy_guidelines": [
+      "Use parallel for independent groups in different files",
+      "Use serial for dependent changes (e.g., shared utilities)",
+      "Limit parallelism to 3 concurrent agents to avoid resource contention",
+      "High-risk groups should be isolated for careful monitoring"
+    ],
+    "test_strategy_guidelines": [
+      "Identify test files related to changed code",
+      "Use specific patterns for faster test execution",
+      "Ensure test coverage captures all fix impacts",
+      "Define clear pass criteria (usually 100% pass rate)"
+    ],
+    "risk_assessment_guidelines": [
+      "Low: Simple fixes with comprehensive test coverage",
+      "Medium: Moderate changes affecting multiple components",
+      "High: Core logic changes or security-critical fixes",
+      "Critical: Database schema changes or breaking API changes"
+    ]
+  }
+}

.ccw/workflows/cli-templates/fix-progress-template.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "fix-progress-template.json",
+  "$comment": "Template for fix-progress-{N}.json - one per group, initialized by planning agent, updated by execution agent",
+
+  "progress_id": "fix-progress-N",
+  "group_id": "GN",
+  "group_name": "Group name from fix plan",
+  "status": "pending",
+  "phase": "waiting",
+
+  "assigned_agent": null,
+  "started_at": null,
+  "last_update": "ISO 8601 timestamp",
+
+  "findings": [
+    {
+      "finding_id": "finding-uuid",
+      "finding_title": "Finding title from review",
+      "file": "path/to/file.ts",
+      "line": 0,
+      "status": "pending",
+      "result": null,
+      "attempts": 0,
+      "started_at": null,
+      "completed_at": null,
+      "commit_hash": null,
+      "test_passed": null
+    }
+  ],
+
+  "summary": {
+    "total_findings": 0,
+    "pending": 0,
+    "in_progress": 0,
+    "fixed": 0,
+    "failed": 0,
+    "percent_complete": 0.0
+  },
+
+  "current_finding": null,
+
+  "flow_control": {
+    "implementation_approach": [],
+    "current_step": null
+  },
+
+  "errors": []
+}

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

@@ -0,0 +1,261 @@
+---
+name: product-owner
+description: Product backlog management, user story creation, and feature prioritization
+---
+
+# Product Owner Planning Template
+
+## Role & Scope
+
+**Role**: Product Owner
+**Focus**: Product backlog management, user story definition, stakeholder alignment, value delivery
+**Excluded**: Team management, technical implementation, detailed system design
+
+## Planning Process (Required)
+Before providing planning document, you MUST:
+1. Analyze product vision and stakeholder needs
+2. Define backlog structure and prioritization framework
+3. Create user stories with acceptance criteria
+4. Plan releases and define success metrics
+5. Present structured planning document
+
+## Planning Document 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

.ccw/workflows/cli-templates/prompts/analysis-analyze-code-patterns.txt

@@ -0,0 +1,37 @@
+Analyze implementation patterns and code structure.
+
+## Planning Required
+Before providing analysis, you MUST:
+1. Review all files in context (not just samples)
+2. Identify patterns with file:line references
+3. Distinguish good patterns from anti-patterns
+4. Apply template requirements
+
+## Core Checklist
+- [ ] Analyze ALL files in CONTEXT
+- [ ] Provide file:line references for each pattern
+- [ ] Distinguish good patterns from anti-patterns
+- [ ] Apply RULES template requirements
+
+## REQUIRED ANALYSIS
+1. Identify common code patterns and architectural decisions
+2. Extract reusable utilities and shared components
+3. Document existing conventions and coding standards
+4. Assess pattern consistency and identify anti-patterns
+5. Suggest improvements and optimization opportunities
+
+## OUTPUT REQUIREMENTS
+- Specific file:line references for all findings
+- Code snippets demonstrating identified patterns
+- Clear recommendations for pattern improvements
+- Standards compliance assessment with priority levels
+
+## Verification Checklist
+Before finalizing output, verify:
+- [ ] All CONTEXT files analyzed
+- [ ] Every pattern has code reference (file:line)
+- [ ] Anti-patterns clearly distinguished
+- [ ] Recommendations prioritized by impact
+
+## Output Requirements
+Provide actionable insights with concrete implementation guidance.

.ccw/workflows/cli-templates/prompts/analysis-analyze-technical-document.txt

@@ -0,0 +1,33 @@
+Analyze technical documents, research papers, and specifications systematically.
+
+## CORE CHECKLIST ⚡
+□ Plan analysis approach before reading (document type, key questions, success criteria)
+□ Provide section/page references for all claims and findings
+□ Distinguish facts from interpretations explicitly
+□ Use precise, direct language - avoid persuasive wording
+□ Apply RULES template requirements exactly as specified
+
+## REQUIRED ANALYSIS
+1. Document assessment: type, structure, audience, quality indicators
+2. Content extraction: concepts, specifications, implementation details, constraints
+3. Critical evaluation: strengths, gaps, ambiguities, clarity issues
+4. Self-critique: verify citations, completeness, actionable recommendations
+5. Synthesis: key takeaways, integration points, follow-up questions
+
+## OUTPUT REQUIREMENTS
+- Structured analysis with mandatory section/page references
+- Evidence-based findings with specific location citations
+- Clear separation of facts vs. interpretations
+- Actionable recommendations tied to document content
+- Integration points with existing project patterns
+- Identified gaps and ambiguities with impact assessment
+
+## VERIFICATION CHECKLIST ✓
+□ Pre-analysis plan documented (3-5 bullet points)
+□ All claims backed by section/page references
+□ Self-critique completed before final output
+□ Language is precise and direct (no persuasive adjectives)
+□ Recommendations are specific and actionable
+□ Output length proportional to document size
+
+Focus: Evidence-based insights extraction with pre-planning and self-critique for technical documents.

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

@@ -0,0 +1,127 @@
+---
+name: bug-diagnosis
+description: 用于定位bug并提供修改建议
+category: development
+keywords: [bug诊断, 故障分析, 修复方案]
+---
+
+# Role & Output Requirements
+
+**Role**: Software engineer specializing in bug diagnosis
+**Output Format**: Diagnostic report in Chinese following the specified structure
+**Constraints**: Do NOT write complete code files. Provide diagnostic analysis and targeted correction suggestions only.
+
+## Core Capabilities
+- Interpret symptoms from bug reports, stack traces, and logs
+- Trace execution flow to identify root causes
+- Formulate and validate hypotheses about bug origins
+- Design targeted, low-risk corrections
+- Analyze impact on other system components
+
+## Analysis Process (Required)
+**Before providing your final diagnosis, you MUST:**
+1. Analyze symptoms and form initial hypothesis
+2. Trace code execution to identify root cause
+3. Design correction strategy
+4. Assess potential impacts and risks
+5. Present structured diagnostic report
+
+## Objectives
+1. Identify root cause (not just symptoms)
+2. Propose targeted correction with justification
+3. Assess risks and side effects
+4. Provide verification steps
+
+## Input
+- Bug description (observed vs. expected behavior)
+- Code snippets or file locations
+- Logs, stack traces, error messages
+- Reproduction steps (if available)
+
+## Output Structure (Required)
+
+Output in Chinese using this Markdown structure:
+
+---
+
+### 0. 诊断思维链 (Diagnostic Chain-of-Thought)
+Present your analysis process in these steps:
+1. **症状分析**: Summarize error symptoms and technical clues
+2. **初步假设**: Identify suspicious code areas and form initial hypothesis
+3. **根本原因定位**: Trace execution path to pinpoint exact cause
+4. **修复方案设计**: Design targeted, low-risk correction
+5. **影响评估**: Assess side effects and plan verification
+
+### **故障诊断与修复建议报告 (Bug Diagnosis & Correction Proposal)**
+
+### **第一部分:故障分析报告 (Part 1: Fault Analysis Report)**
+*   **1.1 故障现象描述 (Bug Symptom Description):**
+    *   **观察到的行为 (Observed Behavior):** [清晰、客观地转述用户报告的异常现象或日志中的错误信息。]
+    *   **预期的行为 (Expected Behavior):** [描述在正常情况下,系统或功能应有的表现。]
+*   **1.2 诊断分析过程 (Diagnostic Analysis Process):**
+    *   **初步假设 (Initial Hypothesis):** [陈述您根据初步信息得出的第一个猜测。例如:初步判断,问题可能出在数据解析环节,因为错误日志显示了格式不匹配。]
+    *   **根本原因分析 (Root Cause Analysis - RCA):** [**这是报告的核心。** 详细阐述您的逻辑推理过程,说明您是如何从表象追踪到根源的。例如:通过检查 `data_parser.py` 的 `parse_record` 函数,发现当输入记录的某个可选字段缺失时,代码并未处理该 `None` 值,而是直接对其调用了 `strip()` 方法,从而导致了 `AttributeError`。因此,**根本原因**是:**对可能为 None 的变量在未进行空值检查的情况下直接调用了方法**。]
+*   **1.3 根本原因摘要 (Root Cause Summary):** [用一句话高度概括 bug 的根本原因。]
+
+### **第二部分:涉及文件概览 (Part 2: Involved Files Overview)**
+*   **文件列表 (File List):** [列出定位到问题或需要修改的所有相关文件名及路径。示例: `- src/parsers/data_parser.py (根本原因所在,直接修改)`]
+
+### **第三部分:详细修复建议 (Part 3: Detailed Correction Plan)**
+---
+*针对每个需要修改的文件进行描述:*
+
+**文件: [文件路径或文件名] (File: [File path or filename])**
+
+*   **1. 定位 (Location):**
+    *   [清晰说明函数、类、方法或具体的代码区域,并指出大致行号。示例: 函数 `parse_record` 内部,约第 125 行]
+
+*   **2. 相关问题代码片段 (Relevant Problematic Code Snippet):**
+    *   [引用导致问题的关键原始代码行,为开发者提供直接上下文。]
+    *   ```[language]
+        // value = record.get(optional_field)
+        // processed_value = value.strip() // 此处引发错误
+        ```
+
+*   **3. 修复描述与预期逻辑 (Correction Description & Intended Logic):**
+    *   **建议修复措施 (Proposed Correction):**
+        *   [用清晰的中文自然语言,描述需要进行的具体修改。例如:在调用 `.strip()` 方法之前,增加一个条件判断,检查 `value` 变量是否不为 `None`。]
+    *   **修复后逻辑示意 (Corrected Logic Sketch):**
+        *   [使用简洁的 `diff` 风格或伪代码来直观展示修改。]
+        *   **示例:**
+            ```diff
+            - processed_value = value.strip()
+            + processed_value = value.strip() if value is not None else None
+            ```
+            *或使用流程图:*
+            ```
+            获取 optional_field ───► [value]
+            ◊─── IF (value is not None) THEN
+            │    └───► value.strip() ───► [processed_value]
+            ELSE
+            │    └─── (赋值为 None) ───► [processed_value]
+            END IF
+            ... (后续逻辑使用 processed_value) ...
+            ```
+    *   **修复理由 (Reason for Correction):** [解释为什么这个修改能解决之前分析出的**根本原因**。例如:此修改确保了只在变量 `value` 存在时才对其进行操作,从而避免了 `AttributeError`,解决了对 None 值的非法调用问题。]
+
+*   **4. 验证建议与风险提示 (Verification Suggestions & Risk Advisory):**
+    *   **验证步骤 (Verification Steps):** [提供具体的测试建议来验证修复是否成功,以及是否引入新问题。例如:1. 构造一个optional_field字段存在的测试用例,确认其能被正常处理。2. **构造一个optional_field字段缺失的测试用例,确认程序不再崩溃,且 `processed_value` 为 `None` 或默认值。**]
+    *   **潜在风险与注意事项 (Potential Risks & Considerations):** [指出此修改可能带来的任何潜在副作用或需要开发者注意的地方。例如:请注意,下游消费 `processed_value` 的代码现在必须能够正确处理 `None` 值。请检查相关调用方是否已做相应处理。]
+
+---
+*(对每个需要修改的文件重复上述格式)*
+
+## Key Requirements
+1. **Language**: All output in Chinese
+2. **No Code Generation**: Use diff format or pseudo-code only. Do not write complete functions or files
+3. **Focus on Root Cause**: Analysis must be logical and evidence-based
+4. **State Assumptions**: Clearly note any assumptions when information is incomplete
+
+## Self-Review Checklist
+Before providing final output, verify:
+- [ ] Diagnostic chain reflects logical debugging process
+- [ ] Root cause analysis is clear and evidence-based
+- [ ] Correction directly addresses root cause (not just symptoms)
+- [ ] Correction is minimal and targeted (not broad refactoring)
+- [ ] Verification steps are actionable
+- [ ] No complete code blocks generated

.ccw/workflows/cli-templates/prompts/development-generate-tests.txt

@@ -0,0 +1,70 @@
+Create comprehensive tests for the codebase.
+
+## Planning Required
+Before creating tests, you MUST:
+1. Analyze existing test coverage and identify gaps
+2. Study testing frameworks and conventions used
+3. Plan test strategy covering unit, integration, and e2e
+4. Design test data management approach
+
+## Core Checklist
+- [ ] Analyze coverage gaps
+- [ ] Follow testing frameworks and conventions
+- [ ] Include unit, integration, and e2e tests
+- [ ] Ensure tests are reliable and deterministic
+
+## IMPLEMENTATION PHASES
+
+### Test Strategy Phase
+1. Analyze existing test coverage and identify gaps
+2. Study codebase architecture and critical paths
+3. Identify edge cases and error scenarios
+4. Review testing frameworks and conventions used
+
+### Unit Testing Phase
+1. Write tests for individual functions and methods
+2. Test all branches and conditional logic
+3. Cover edge cases and boundary conditions
+4. Mock external dependencies appropriately
+
+### Integration Testing Phase
+1. Test interactions between components and modules
+2. Verify API endpoints and data flow
+3. Test database operations and transactions
+4. Validate external service integrations
+
+### End-to-End Testing Phase
+1. Test complete user workflows and scenarios
+2. Verify critical business logic and processes
+3. Test error handling and recovery mechanisms
+4. Validate performance under load
+
+### Quality Assurance
+1. Ensure tests are reliable and deterministic
+2. Make tests readable and maintainable
+3. Add proper test documentation and comments
+4. Follow testing best practices and conventions
+
+### Test Data Management
+1. Create realistic test data and fixtures
+2. Ensure test isolation and cleanup
+3. Use factories or builders for complex objects
+4. Handle sensitive data appropriately in tests
+
+## OUTPUT REQUIREMENTS
+- Comprehensive test suite with high coverage
+- Performance benchmarks where relevant
+- Testing strategy and conventions documentation
+- Test coverage metrics and quality improvements
+- File:line references for tested code
+
+## Verification Checklist
+Before finalizing, verify:
+- [ ] Coverage gaps filled
+- [ ] All test types included
+- [ ] Tests are reliable (no flaky tests)
+- [ ] Test data properly managed
+- [ ] Conventions followed
+
+## Focus
+High-quality, reliable test suite with comprehensive coverage.

.ccw/workflows/cli-templates/prompts/development-implement-feature.txt

@@ -0,0 +1,58 @@
+Implement a new feature following project conventions and best practices.
+
+## Planning Required
+Before implementing, you MUST:
+1. Study existing code patterns and conventions
+2. Review project architecture and design principles
+3. Plan implementation with error handling and tests
+4. Document integration points and dependencies
+
+## Core Checklist
+- [ ] Study existing code patterns first
+- [ ] Follow project conventions and architecture
+- [ ] Include comprehensive tests
+- [ ] Provide file:line references
+
+## IMPLEMENTATION PHASES
+
+### Analysis Phase
+1. Study existing code patterns and conventions
+2. Identify similar features and their implementation approaches
+3. Review project architecture and design principles
+4. Understand dependencies and integration points
+
+### Implementation Phase
+1. Create feature following established patterns
+2. Implement with proper error handling and validation
+3. Add comprehensive logging for debugging
+4. Follow security best practices
+
+### Integration Phase
+1. Ensure seamless integration with existing systems
+2. Update configuration files as needed
+3. Add proper TypeScript types and interfaces
+4. Update documentation and comments
+
+### Testing Phase
+1. Write unit tests covering edge cases
+2. Add integration tests for feature workflows
+3. Verify error scenarios are properly handled
+4. Test performance and security implications
+
+## OUTPUT REQUIREMENTS
+- File:line references for all changes
+- Code examples demonstrating key patterns
+- Explanation of architectural decisions made
+- Documentation of new dependencies or configurations
+- Test coverage summary
+
+## Verification Checklist
+Before finalizing, verify:
+- [ ] Follows existing patterns
+- [ ] Complete test coverage
+- [ ] Documentation updated
+- [ ] No breaking changes
+- [ ] Security and performance validated
+
+## Focus
+Production-ready implementation with comprehensive testing and documentation.

.ccw/workflows/cli-templates/prompts/documentation-module-readme.txt

@@ -0,0 +1,49 @@
+Generate module documentation focused on understanding and usage.
+
+## Planning Required
+Before providing documentation, you MUST:
+1. Understand what the module does and why it exists
+2. Review existing documentation to avoid duplication
+3. Prepare practical usage examples
+4. Identify module boundaries and dependencies
+
+## Core Checklist
+- [ ] Explain WHAT, WHY, and HOW
+- [ ] Reference API.md instead of duplicating signatures
+- [ ] Include practical usage examples
+- [ ] Define module boundaries and dependencies
+
+## DOCUMENTATION STRUCTURE
+
+### 1. Purpose
+- **What**: Clearly state what this module is responsible for.
+- **Why**: Explain the problem it solves.
+- **Boundaries**: Define what is in and out of scope.
+
+### 2. Core Concepts
+- Explain key concepts, patterns, or abstractions.
+
+### 3. Usage Scenarios
+- Provide 2-4 common use cases with code examples.
+
+### 4. Dependencies
+- List internal and external dependencies with explanations.
+
+### 5. Configuration
+- Document environment variables and configuration options.
+
+### 6. Testing
+- Explain how to run tests for the module.
+
+### 7. Common Issues
+- List common problems and their solutions.
+
+## Verification Checklist
+Before finalizing output, verify:
+- [ ] Module purpose, scope, and boundaries are clear
+- [ ] Core concepts are explained
+- [ ] Usage examples are practical and realistic
+- [ ] Dependencies and configuration are documented
+
+## Focus
+Explain module purpose and usage, not just API details.

.ccw/workflows/cli-templates/prompts/documentation-swagger-api.txt

@@ -0,0 +1,266 @@
+生成符合 RESTful 规范的完整 Swagger/OpenAPI API 文档。
+
+## 核心检查清单 ⚡
+□ 严格遵循 RESTful API 设计规范
+□ 每个接口必须包含：功能描述、请求方法、URL路径、参数说明
+□ 必须包含全局 Security 配置（Authorization Bearer Token）
+□ 使用中文命名目录，保持层级清晰
+□ 每个字段需注明：类型、是否必填、示例值、说明
+□ 包含成功和失败的响应示例
+□ 标注接口版本和最后更新时间
+
+## OpenAPI 规范结构
+
+### 1. 文档信息 (info)
+```yaml
+openapi: 3.0.3
+info:
+  title: {项目名称} API
+  description: |
+    {项目描述}
+    
+    ## 认证方式
+    所有需要认证的接口必须在请求头中携带 Bearer Token：
+    ```
+    Authorization: Bearer <your-token>
+    ```
+  version: "1.0.0"
+  contact:
+    name: API 支持
+    email: api-support@example.com
+  license:
+    name: MIT
+```
+
+### 2. 服务器配置 (servers)
+```yaml
+servers:
+  - url: https://api.example.com/v1
+    description: 生产环境
+  - url: https://staging-api.example.com/v1
+    description: 测试环境
+  - url: http://localhost:3000/v1
+    description: 开发环境
+```
+
+### 3. 全局安全配置 (security)
+```yaml
+components:
+  securitySchemes:
+    bearerAuth:
+      type: http
+      scheme: bearer
+      bearerFormat: JWT
+      description: |
+        JWT Token 认证
+        
+        获取方式：调用 POST /auth/login 接口
+        有效期：24小时
+        刷新：调用 POST /auth/refresh 接口
+
+security:
+  - bearerAuth: []
+```
+
+### 4. 接口路径规范 (paths)
+```yaml
+paths:
+  /users:
+    get:
+      tags:
+        - 用户管理
+      summary: 获取用户列表
+      description: |
+        分页获取系统用户列表，支持按状态、角色筛选。
+        
+        **适用环境**: 开发、测试、生产
+        **前置条件**: 需要管理员权限
+      operationId: listUsers
+      security:
+        - bearerAuth: []
+      parameters:
+        - name: page
+          in: query
+          required: false
+          schema:
+            type: integer
+            default: 1
+            minimum: 1
+          description: 页码（从1开始）
+          example: 1
+        - name: limit
+          in: query
+          required: false
+          schema:
+            type: integer
+            default: 20
+            minimum: 1
+            maximum: 100
+          description: 每页数量
+          example: 20
+      responses:
+        '200':
+          description: 成功获取用户列表
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/UserListResponse'
+              example:
+                code: 0
+                message: success
+                data:
+                  items:
+                    - id: "usr_123"
+                      email: "user@example.com"
+                      name: "张三"
+                  total: 100
+                  page: 1
+                  limit: 20
+        '401':
+          $ref: '#/components/responses/UnauthorizedError'
+        '403':
+          $ref: '#/components/responses/ForbiddenError'
+```
+
+### 5. 数据模型规范 (schemas)
+```yaml
+components:
+  schemas:
+    # 基础响应结构
+    BaseResponse:
+      type: object
+      required:
+        - code
+        - message
+        - timestamp
+      properties:
+        code:
+          type: integer
+          description: 业务状态码，0表示成功
+          example: 0
+        message:
+          type: string
+          description: 响应消息
+          example: success
+        timestamp:
+          type: string
+          format: date-time
+          description: 响应时间戳
+          example: "2025-01-01T12:00:00Z"
+    
+    # 错误响应
+    ErrorResponse:
+      type: object
+      required:
+        - code
+        - message
+      properties:
+        code:
+          type: string
+          description: 错误码
+          example: "AUTH_001"
+        message:
+          type: string
+          description: 错误信息
+          example: "Token 无效或已过期"
+        details:
+          type: object
+          description: 错误详情
+          additionalProperties: true
+```
+
+### 6. 统一响应定义 (responses)
+```yaml
+components:
+  responses:
+    UnauthorizedError:
+      description: 认证失败
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/ErrorResponse'
+          example:
+            code: "AUTH_001"
+            message: "Token 无效或已过期"
+    ForbiddenError:
+      description: 权限不足
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/ErrorResponse'
+          example:
+            code: "AUTH_003"
+            message: "权限不足，需要管理员角色"
+    NotFoundError:
+      description: 资源不存在
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/ErrorResponse'
+          example:
+            code: "BIZ_002"
+            message: "资源不存在"
+    ValidationError:
+      description: 参数验证失败
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/ErrorResponse'
+          example:
+            code: "PARAM_001"
+            message: "参数格式错误"
+            details:
+              field: "email"
+              reason: "邮箱格式不正确"
+```
+
+## 接口文档必填项
+
+每个接口必须包含：
+
+1. **基本信息**
+   - tags: 所属模块（中文）
+   - summary: 一句话描述
+   - description: 详细说明（含适用环境、前置条件）
+   - operationId: 唯一操作标识
+
+2. **安全配置**
+   - security: 认证要求
+
+3. **参数定义**
+   - name: 参数名
+   - in: 位置 (path/query/header/cookie)
+   - required: 是否必填
+   - schema: 类型定义（含 default, minimum, maximum）
+   - description: 参数说明
+   - example: 示例值
+
+4. **响应定义**
+   - 200: 成功响应（含完整示例）
+   - 400: 参数错误
+   - 401: 认证失败
+   - 403: 权限不足
+   - 404: 资源不存在（如适用）
+   - 500: 服务器错误
+
+5. **版本信息**
+   - x-version: 接口版本
+   - x-updated: 最后更新时间
+
+## 错误码规范
+
+| 前缀 | 类别 | HTTP状态码 | 说明 |
+|------|------|------------|------|
+| AUTH_ | 认证错误 | 401/403 | 身份验证相关 |
+| PARAM_ | 参数错误 | 400 | 请求参数验证 |
+| BIZ_ | 业务错误 | 409/422 | 业务逻辑相关 |
+| SYS_ | 系统错误 | 500/503 | 服务器异常 |
+
+## RESTful 设计规范
+
+1. **URL 命名**: 使用复数名词，小写，连字符分隔
+2. **HTTP 方法**: GET(查询)、POST(创建)、PUT(更新)、DELETE(删除)、PATCH(部分更新)
+3. **状态码**: 正确使用 2xx/3xx/4xx/5xx
+4. **分页**: 使用 page/limit 或 offset/limit
+5. **筛选**: 使用查询参数
+6. **版本**: URL 路径 (/v1/) 或 请求头

.ccw/workflows/cli-templates/prompts/planning-plan-architecture-design.txt

@@ -0,0 +1,109 @@
+# 软件架构规划模板
+
+## Role & Output Requirements
+
+**Role**: Software architect specializing in technical planning
+**Output Format**: Modification plan in Chinese following the specified structure
+**Constraints**: Do NOT write or generate code. Provide planning and strategy only.
+
+## Core Capabilities
+- Understand complex codebases (structure, patterns, dependencies, data flow)
+- Analyze requirements and translate to technical objectives
+- Apply software design principles (SOLID, DRY, KISS, design patterns)
+- Assess impacts, dependencies, and risks
+- Create step-by-step modification plans
+
+## Planning Process (Required)
+**Before providing your final plan, you MUST:**
+1. Analyze requirements and identify technical objectives
+2. Explore existing code structure and patterns
+3. Identify modification points and formulate strategy
+4. Assess dependencies and risks
+5. Present structured modification plan
+
+## Objectives
+1. Understand context (code, requirements, project background)
+2. Analyze relevant code sections and their relationships
+3. Create step-by-step modification plan (what, where, why, how)
+4. Illustrate intended logic using call flow diagrams
+5. Provide implementation context (variables, dependencies, side effects)
+
+## Input
+- Code snippets or file locations
+- Modification requirements and goals
+- Project context (if available)
+
+## Output Structure (Required)
+
+Output in Chinese using this Markdown structure:
+
+---
+
+### 0. 思考过程与规划策略 (Thinking Process & Planning Strategy)
+Present your planning process in these steps:
+1. **需求解析**: Break down requirements and clarify core objectives
+2. **代码结构勘探**: Analyze current code structure and logic flow
+3. **核心修改点识别**: Identify modification points and formulate strategy
+4. **依赖与风险评估**: Assess dependencies and risks
+5. **规划文档组织**: Organize planning document
+
+### **代码修改规划方案 (Code Modification Plan)**
+
+### **第一部分:需求分析与规划总览 (Part 1: Requirements Analysis & Planning Overview)**
+*   **1.1 用户原始需求结构化解析 (Structured Analysis of Users Original Requirements):**
+    *   [将用户的原始需求拆解成一个或多个清晰、独立、可操作的要点列表。每个要点都是一个明确的目标。]
+    *   **- 需求点 A:** [描述第一个具体需求]
+    *   **- 需求点 B:** [描述第二个具体需求]
+    *   **- ...**
+*   **1.2 技术实现目标与高级策略 (Technical Implementation Goals & High-Level Strategy):**
+    *   [基于上述需求分析,将其转化为具体的、可衡量的技术目标。并简述为达成这些目标将采用的整体技术思路或架构策略。例如:为实现【需求点A】,我们需要在 `ServiceA` 中引入一个新的处理流程。为实现【需求点B】,我们将重构 `ModuleB` 的数据验证逻辑,以提高其扩展性。]
+
+### **第二部分:涉及文件概览 (Part 2: Involved Files Overview)**
+*   **文件列表 (File List):** [列出所有识别出的相关文件名(若路径已知/可推断,请包含路径)。不仅包括直接修改的文件,也包括提供关键上下文或可能受间接影响的文件。示例: `- src/core/module_a.py (直接修改)`, `- src/utils/helpers.py (依赖项,可能受影响)`, `- configs/settings.json (配置参考)`]
+
+### **第三部分:详细修改计划 (Part 3: Detailed Modification Plan)**
+---
+*针对每个需要直接修改的文件进行描述:*
+
+**文件: [文件路径或文件名] (File: [File path or filename])**
+
+*   **1. 位置 (Location):**
+    *   [清晰说明函数、类、方法或具体的代码区域,如果可能,指出大致行号范围。示例: 函数 `calculate_total_price` 内部,约第 75-80 行]
+
+*   **1.bis 相关原始代码片段 (Relevant Original Code Snippet):**
+    *   [**在此处引用需要修改或在其附近进行修改的、最相关的几行原始代码。** 这为开发者提供了直接的上下文。如果代码未提供,则注明相关代码未提供,根据描述进行规划。]
+    *   ```[language]
+        // 引用相关的1-5行原始代码
+        ```
+
+*   **2. 修改描述与预期逻辑 (Modification Description & Intended Logic):**
+    *   **当前状态简述 (Brief Current State):** [可选,如果有助于理解变更,简述当前位置代码的核心功能。]
+    *   **拟议修改点 (Proposed Changes):**
+        *   [分步骤详细描述需要进行的逻辑更改。用清晰的中文自然语言解释 *什么* 需要被改变或添加。]
+    *   **预期逻辑与数据流示意 (Intended Logic and Data Flow Sketch):**
+        *   [使用简洁调用图的风格,描述此修改点引入或改变后的 *预期* 控制流程和关键数据传递。]
+        *   [**图例参考**: `───►` 调用/流程转向, `◄───` 返回/结果, `◊───` 条件分支, `ループ` 循环块, `[数据]` 表示关键数据, `// 注释` ]
+    *   **修改理由 (Reason for Modification):** [解释 *为什么* 这个修改是必要的,并明确关联到 **第一部分** 中解析出的某个【需求点】或【技术目标】。]
+    *   **预期结果 (Intended Outcome):** [描述此修改完成后,该代码段预期的行为或产出。]
+
+*   **3. 必要上下文与注意事项 (Necessary Context & Considerations):**
+    *   [提及实施者在进行此特定更改时必须了解的关键变量、数据结构、已有函数的依赖关系、新引入的依赖。]
+    *   [**重点指出**潜在的连锁反应、对其他模块的可能影响、性能考量、错误处理、事务性、并发问题或数据完整性等重要风险点。]
+
+---
+*(对每个需要修改的文件重复上述格式)*
+
+## Key Requirements
+1. **Language**: All output in Chinese
+2. **No Code Generation**: Do not write actual code. Provide descriptive modification plan only
+3. **Focus**: Detail what and why. Use logic sketches to illustrate how
+4. **Completeness**: State assumptions clearly when information is incomplete
+
+## Self-Review Checklist
+Before providing final output, verify:
+- [ ] Thinking process outlines structured analytical approach
+- [ ] All requirements addressed in the plan
+- [ ] Plan is logical, actionable, and detailed
+- [ ] Modification reasons link back to requirements
+- [ ] Context and risks are highlighted
+- [ ] No actual code generated

.ccw/workflows/cli-templates/prompts/rules-rule-api.txt

@@ -0,0 +1,122 @@
+# Rule Template: API Rules (Backend/Fullstack Only)
+
+## Variables
+- {TECH_STACK_NAME}: Tech stack display name
+- {FILE_EXT}: File extension pattern
+- {API_FRAMEWORK}: API framework (Express, FastAPI, etc)
+
+## Output Format
+
+```markdown
+---
+paths:
+  - "**/api/**/*.{FILE_EXT}"
+  - "**/routes/**/*.{FILE_EXT}"
+  - "**/endpoints/**/*.{FILE_EXT}"
+  - "**/controllers/**/*.{FILE_EXT}"
+  - "**/handlers/**/*.{FILE_EXT}"
+---
+
+# {TECH_STACK_NAME} API Rules
+
+## Endpoint Design
+
+[REST/GraphQL conventions from Exa research]
+
+### URL Structure
+- Resource naming (plural nouns)
+- Nesting depth limits
+- Query parameter conventions
+- Version prefixing
+
+### HTTP Methods
+- GET: Read operations
+- POST: Create operations
+- PUT/PATCH: Update operations
+- DELETE: Remove operations
+
+### Status Codes
+- 2xx: Success responses
+- 4xx: Client errors
+- 5xx: Server errors
+
+## Request Validation
+
+[Input validation patterns]
+
+### Schema Validation
+```{lang}
+// Example validation schema
+```
+
+### Required Fields
+- Validation approach
+- Error messages format
+- Sanitization rules
+
+## Response Format
+
+[Standard response structures]
+
+### Success Response
+```json
+{
+  "data": {},
+  "meta": {}
+}
+```
+
+### Pagination
+```json
+{
+  "data": [],
+  "pagination": {
+    "page": 1,
+    "limit": 20,
+    "total": 100
+  }
+}
+```
+
+## Error Responses
+
+[Error handling for APIs]
+
+### Error Format
+```json
+{
+  "error": {
+    "code": "ERROR_CODE",
+    "message": "Human readable message",
+    "details": {}
+  }
+}
+```
+
+### Common Error Codes
+- VALIDATION_ERROR
+- NOT_FOUND
+- UNAUTHORIZED
+- FORBIDDEN
+
+## Authentication & Authorization
+
+[Auth patterns]
+- Token handling
+- Permission checks
+- Rate limiting
+
+## Documentation
+
+[API documentation standards]
+- OpenAPI/Swagger
+- Inline documentation
+- Example requests/responses
+```
+
+## Content Guidelines
+
+- Focus on API-specific patterns
+- Include request/response examples
+- Cover security considerations
+- Reference framework conventions

.ccw/workflows/cli-templates/prompts/rules-rule-components.txt

@@ -0,0 +1,122 @@
+# Rule Template: Component Rules (Frontend/Fullstack Only)
+
+## Variables
+- {TECH_STACK_NAME}: Tech stack display name
+- {FILE_EXT}: File extension pattern
+- {UI_FRAMEWORK}: UI framework (React, Vue, etc)
+
+## Output Format
+
+```markdown
+---
+paths:
+  - "**/components/**/*.{FILE_EXT}"
+  - "**/ui/**/*.{FILE_EXT}"
+  - "**/views/**/*.{FILE_EXT}"
+  - "**/pages/**/*.{FILE_EXT}"
+---
+
+# {TECH_STACK_NAME} Component Rules
+
+## Component Structure
+
+[Organization patterns from Exa research]
+
+### File Organization
+```
+components/
+├── common/          # Shared components
+├── features/        # Feature-specific
+├── layout/          # Layout components
+└── ui/              # Base UI elements
+```
+
+### Component Template
+```{lang}
+// Standard component structure
+```
+
+### Naming Conventions
+- PascalCase for components
+- Descriptive names
+- Prefix conventions (if any)
+
+## Props & State
+
+[State management guidelines]
+
+### Props Definition
+```{lang}
+// Props type/interface example
+```
+
+### Props Best Practices
+- Required vs optional
+- Default values
+- Prop validation
+- Prop naming
+
+### Local State
+- When to use local state
+- State initialization
+- State updates
+
+### Shared State
+- State management approach
+- Context usage
+- Store patterns
+
+## Styling
+
+[CSS/styling conventions]
+
+### Approach
+- [CSS Modules/Styled Components/Tailwind/etc]
+
+### Style Organization
+```{lang}
+// Style example
+```
+
+### Naming Conventions
+- Class naming (BEM, etc)
+- CSS variable usage
+- Theme integration
+
+## Accessibility
+
+[A11y requirements]
+
+### Essential Requirements
+- Semantic HTML
+- ARIA labels
+- Keyboard navigation
+- Focus management
+
+### Testing A11y
+- Automated checks
+- Manual testing
+- Screen reader testing
+
+## Performance
+
+[Performance guidelines]
+
+### Optimization Patterns
+- Memoization
+- Lazy loading
+- Code splitting
+- Virtual lists
+
+### Avoiding Re-renders
+- When to memoize
+- Callback optimization
+- State structure
+```
+
+## Content Guidelines
+
+- Focus on component-specific patterns
+- Include framework-specific examples
+- Cover accessibility requirements
+- Address performance considerations

.ccw/workflows/cli-templates/prompts/rules-rule-config.txt

@@ -0,0 +1,89 @@
+# Rule Template: Configuration Rules
+
+## Variables
+- {TECH_STACK_NAME}: Tech stack display name
+- {CONFIG_FILES}: List of config file patterns
+
+## Output Format
+
+```markdown
+---
+paths:
+  - "*.config.*"
+  - ".*rc"
+  - ".*rc.{js,json,yaml,yml}"
+  - "package.json"
+  - "tsconfig*.json"
+  - "pyproject.toml"
+  - "Cargo.toml"
+  - "go.mod"
+  - ".env*"
+---
+
+# {TECH_STACK_NAME} Configuration Rules
+
+## Project Setup
+
+[Configuration guidelines from Exa research]
+
+### Essential Config Files
+- [List primary config files]
+- [Purpose of each]
+
+### Recommended Structure
+```
+project/
+├── [config files]
+├── src/
+└── tests/
+```
+
+## Tooling
+
+[Linters, formatters, bundlers]
+
+### Linting
+- Tool: [ESLint/Pylint/etc]
+- Config file: [.eslintrc/pyproject.toml/etc]
+- Key rules to enable
+
+### Formatting
+- Tool: [Prettier/Black/etc]
+- Integration with editor
+- Pre-commit hooks
+
+### Build Tools
+- Bundler: [Webpack/Vite/etc]
+- Build configuration
+- Optimization settings
+
+## Environment
+
+[Environment management]
+
+### Environment Variables
+- Naming conventions
+- Required vs optional
+- Secret handling
+- .env file structure
+
+### Development vs Production
+- Environment-specific configs
+- Feature flags
+- Debug settings
+
+## Dependencies
+
+[Dependency management]
+- Lock file usage
+- Version pinning strategy
+- Security updates
+- Peer dependencies
+```
+
+## Content Guidelines
+
+- Focus on config file best practices
+- Include security considerations
+- Cover development workflow setup
+- Mention CI/CD integration where relevant

.ccw/workflows/cli-templates/prompts/rules-rule-core.txt

@@ -0,0 +1,60 @@
+# Rule Template: Core Principles
+
+## Variables
+- {TECH_STACK_NAME}: Tech stack display name
+- {FILE_EXT}: File extension pattern
+
+## Output Format
+
+```markdown
+---
+paths: **/*.{FILE_EXT}
+---
+
+# {TECH_STACK_NAME} Core Principles
+
+## Philosophy
+
+[Synthesize core philosophy from Exa research]
+- Key paradigms and mental models
+- Design philosophy
+- Community conventions
+
+## Naming Conventions
+
+[Language-specific naming rules]
+- Variables and functions
+- Classes and types
+- Files and directories
+- Constants and enums
+
+## Code Organization
+
+[Structure and module guidelines]
+- File structure patterns
+- Module boundaries
+- Import organization
+- Dependency management
+
+## Type Safety
+
+[Type system best practices - if applicable]
+- Type annotation guidelines
+- Generic usage patterns
+- Type inference vs explicit types
+- Null/undefined handling
+
+## Documentation
+
+[Documentation standards]
+- Comment style
+- JSDoc/docstring format
+- README conventions
+```
+
+## Content Guidelines
+
+- Focus on universal principles that apply to ALL files
+- Keep rules actionable and specific
+- Include rationale for each rule
+- Reference official style guides where applicable

.ccw/workflows/cli-templates/prompts/rules-rule-patterns.txt

@@ -0,0 +1,70 @@
+# Rule Template: Implementation Patterns
+
+## Variables
+- {TECH_STACK_NAME}: Tech stack display name
+- {FILE_EXT}: File extension pattern
+
+## Output Format
+
+```markdown
+---
+paths: src/**/*.{FILE_EXT}
+---
+
+# {TECH_STACK_NAME} Implementation Patterns
+
+## Common Patterns
+
+[With code examples from Exa research]
+
+### Pattern 1: [Name]
+```{lang}
+// Example code
+```
+**When to use**: [Context]
+**Benefits**: [Why this pattern]
+
+### Pattern 2: [Name]
+...
+
+## Anti-Patterns to Avoid
+
+[Common mistakes with examples]
+
+### Anti-Pattern 1: [Name]
+```{lang}
+// Bad example
+```
+**Problem**: [Why it's bad]
+**Solution**: [Better approach]
+
+## Error Handling
+
+[Error handling conventions]
+- Error types and hierarchy
+- Try-catch patterns
+- Error propagation
+- Logging practices
+
+## Async Patterns
+
+[Asynchronous code conventions - if applicable]
+- Promise handling
+- Async/await usage
+- Concurrency patterns
+- Error handling in async code
+
+## State Management
+
+[State handling patterns]
+- Local state patterns
+- Shared state approaches
+- Immutability practices
+```
+
+## Content Guidelines
+
+- Focus on source code implementation
+- Provide concrete code examples
+- Show both good and bad patterns
+- Include context for when to apply each pattern

.ccw/workflows/cli-templates/prompts/rules-rule-testing.txt

@@ -0,0 +1,81 @@
+# Rule Template: Testing Rules
+
+## Variables
+- {TECH_STACK_NAME}: Tech stack display name
+- {FILE_EXT}: File extension pattern
+- {TEST_FRAMEWORK}: Primary testing framework
+
+## Output Format
+
+```markdown
+---
+paths:
+  - "**/*.{test,spec}.{FILE_EXT}"
+  - "tests/**/*.{FILE_EXT}"
+  - "__tests__/**/*.{FILE_EXT}"
+  - "**/test_*.{FILE_EXT}"
+  - "**/*_test.{FILE_EXT}"
+---
+
+# {TECH_STACK_NAME} Testing Rules
+
+## Testing Framework
+
+[Recommended frameworks from Exa research]
+- Primary: {TEST_FRAMEWORK}
+- Assertion library
+- Mocking library
+- Coverage tool
+
+## Test Structure
+
+[Organization patterns]
+
+### File Naming
+- Unit tests: `*.test.{ext}` or `*.spec.{ext}`
+- Integration tests: `*.integration.test.{ext}`
+- E2E tests: `*.e2e.test.{ext}`
+
+### Test Organization
+```{lang}
+describe('[Component/Module]', () => {
+  describe('[method/feature]', () => {
+    it('should [expected behavior]', () => {
+      // Arrange
+      // Act
+      // Assert
+    });
+  });
+});
+```
+
+## Mocking & Fixtures
+
+[Best practices]
+- Mock creation patterns
+- Fixture organization
+- Test data factories
+- Cleanup strategies
+
+## Assertions
+
+[Assertion patterns]
+- Common assertions
+- Custom matchers
+- Async assertions
+- Error assertions
+
+## Coverage Requirements
+
+[Coverage guidelines]
+- Minimum coverage thresholds
+- What to cover vs skip
+- Coverage report interpretation
+```
+
+## Content Guidelines
+
+- Include framework-specific patterns
+- Show test structure examples
+- Cover both unit and integration testing
+- Include async testing patterns

.ccw/workflows/cli-templates/prompts/rules-tech-rules-agent-prompt.txt

@@ -0,0 +1,89 @@
+# Tech Stack Rules Generation Agent Prompt
+
+## Context Variables
+- {TECH_STACK_NAME}: Normalized tech stack name (e.g., "typescript-react")
+- {PRIMARY_LANG}: Primary language (e.g., "typescript")
+- {FILE_EXT}: File extension pattern (e.g., "{ts,tsx}")
+- {FRAMEWORK_TYPE}: frontend | backend | fullstack | library
+- {COMPONENTS}: Array of tech components
+- {OUTPUT_DIR}: .claude/rules/tech/{TECH_STACK_NAME}/
+
+## Agent Instructions
+
+Generate path-conditional rules for Claude Code automatic loading.
+
+### Step 1: Execute Exa Research
+
+Run 4-6 parallel queries based on tech stack:
+
+**Base Queries** (always execute):
+```
+mcp__exa__get_code_context_exa(query: "{PRIMARY_LANG} best practices principles 2025", tokensNum: 8000)
+mcp__exa__get_code_context_exa(query: "{PRIMARY_LANG} implementation patterns examples", tokensNum: 7000)
+mcp__exa__get_code_context_exa(query: "{PRIMARY_LANG} testing strategies conventions", tokensNum: 5000)
+mcp__exa__web_search_exa(query: "{PRIMARY_LANG} configuration setup 2025", numResults: 5)
+```
+
+**Component Queries** (for each framework in COMPONENTS):
+```
+mcp__exa__get_code_context_exa(query: "{PRIMARY_LANG} {component} integration patterns", tokensNum: 5000)
+```
+
+### Step 2: Read Rule Templates
+
+Read each template file before generating content:
+```
+Read(~/.ccw/workflows/cli-templates/prompts/rules/rule-core.txt)
+Read(~/.ccw/workflows/cli-templates/prompts/rules/rule-patterns.txt)
+Read(~/.ccw/workflows/cli-templates/prompts/rules/rule-testing.txt)
+Read(~/.ccw/workflows/cli-templates/prompts/rules/rule-config.txt)
+Read(~/.ccw/workflows/cli-templates/prompts/rules/rule-api.txt)       # Only if backend/fullstack
+Read(~/.ccw/workflows/cli-templates/prompts/rules/rule-components.txt) # Only if frontend/fullstack
+```
+
+### Step 3: Generate Rule Files
+
+Create directory and write files:
+```bash
+mkdir -p "{OUTPUT_DIR}"
+```
+
+**Always Generate**:
+- core.md (from rule-core.txt template)
+- patterns.md (from rule-patterns.txt template)
+- testing.md (from rule-testing.txt template)
+- config.md (from rule-config.txt template)
+
+**Conditional**:
+- api.md: Only if FRAMEWORK_TYPE == 'backend' or 'fullstack'
+- components.md: Only if FRAMEWORK_TYPE == 'frontend' or 'fullstack'
+
+### Step 4: Write Metadata
+
+```json
+{
+  "tech_stack": "{TECH_STACK_NAME}",
+  "primary_lang": "{PRIMARY_LANG}",
+  "file_ext": "{FILE_EXT}",
+  "framework_type": "{FRAMEWORK_TYPE}",
+  "components": ["{COMPONENTS}"],
+  "generated_at": "{ISO_TIMESTAMP}",
+  "source": "exa-research",
+  "files_generated": ["core.md", "patterns.md", "testing.md", "config.md", ...]
+}
+```
+
+### Step 5: Report Completion
+
+Provide summary:
+- Files created with their path patterns
+- Exa queries executed (count)
+- Sources consulted (count)
+
+## Critical Requirements
+
+1. Every .md file MUST start with `paths` YAML frontmatter
+2. Use {FILE_EXT} consistently across all rule files
+3. Synthesize Exa research into actionable rules
+4. Include code examples from Exa sources
+5. Keep each file focused on its specific domain

.ccw/workflows/cli-templates/prompts/test-suggestions-enhancement.txt

@@ -0,0 +1,38 @@
+PURPOSE: Generate comprehensive multi-layer test enhancement suggestions
+  - Success: Cover L0-L3 layers with focus on API, integration, and error scenarios
+  - Scope: Files with coverage gaps identified in TEST_ANALYSIS_RESULTS.md
+  - Goal: Provide specific, actionable test case suggestions that increase coverage completeness
+
+TASK:
+  • L1 (Unit Tests): Suggest edge cases, boundary conditions, error paths, state transitions
+  • L2.1 (Integration): Suggest module interaction patterns, dependency injection scenarios
+  • L2.2 (API Contracts): Suggest request/response test cases, validation, status codes, error responses
+  • L2.4 (External APIs): Suggest mock strategies, failure scenarios, timeout handling, retry logic
+  • L2.5 (Failure Modes): Suggest exception hierarchies, error propagation, recovery strategies
+  • Cross-cutting: Suggest performance test cases, security considerations
+
+MODE: analysis
+
+CONTEXT: @.workflow/active/{test-session-id}/.process/TEST_ANALYSIS_RESULTS.md
+  Memory: Project type, test framework, existing test patterns, coverage gaps
+
+EXPECTED: Markdown report with structured test enhancement suggestions organized by:
+  1. File-level test requirements (per file needing tests)
+  2. Layer-specific test cases (L1, L2.1, L2.2, L2.4, L2.5)
+  3. Each suggestion includes:
+     - Test type and layer (e.g., "L2.2 API Contract Test")
+     - Specific test case description (e.g., "POST /api/users - Invalid email format")
+     - Expected behavior (e.g., "Returns 400 with validation error message")
+     - Dependencies/mocks needed (e.g., "Mock email service")
+     - Success criteria (e.g., "Status 400, error.field === 'email'")
+  4. Test ordering/dependencies (which tests should run first)
+  5. Integration test strategies (how components interact)
+  6. Error scenario matrix (all failure modes covered)
+
+CONSTRAINTS:
+  - Focus on identified coverage gaps from TEST_ANALYSIS_RESULTS.md
+  - Prioritize API tests, integration tests, and error scenarios
+  - No code generation - suggestions only with sufficient detail for implementation
+  - Consider project conventions and existing test patterns
+  - Each suggestion should be actionable and specific (not generic)
+  - Output format: Markdown with clear section headers

.ccw/workflows/cli-templates/prompts/test-test-concept-analysis.txt

@@ -0,0 +1,179 @@
+PURPOSE: Analyze test coverage gaps and design comprehensive test generation strategy
+TASK:
+• Read test-context-package.json to understand coverage gaps and framework
+• Study implementation context from source session summaries
+• Analyze existing test patterns and conventions
+• Design test requirements for missing coverage
+• Generate actionable test generation strategy
+MODE: analysis
+CONTEXT: @test-context-package.json @../../../{source-session-id}/.summaries/*.md
+EXPECTED: Comprehensive test analysis document (gemini-test-analysis.md) with test requirements, scenarios, and generation strategy
+RULES:
+- Focus on test requirements and strategy, NOT code generation
+- Study existing test patterns for consistency
+- Prioritize critical business logic tests
+- Specify clear test scenarios and coverage targets
+- Identify all dependencies requiring mocks
+- Output ONLY test analysis and generation strategy
+
+## ANALYSIS REQUIREMENTS
+
+### 1. Implementation Understanding
+- Load all implementation summaries from source session
+- Understand implemented features, APIs, and business logic
+- Extract key functions, classes, and modules
+- Identify integration points and dependencies
+
+### 2. Existing Test Pattern Analysis
+- Study existing test files for patterns and conventions
+- Identify test structure (describe/it, test suites, fixtures)
+- Analyze assertion patterns and mocking strategies
+- Extract test setup/teardown patterns
+
+### 3. Coverage Gap Assessment
+For each file in missing_tests[], analyze:
+- File purpose and functionality
+- Public APIs requiring test coverage
+- Critical paths and edge cases
+- Integration points requiring tests
+- Priority: high (core logic), medium (utilities), low (helpers)
+
+### 4. Test Requirements Specification
+For each missing test file, specify:
+- Test scope: What needs to be tested
+- Test scenarios: Happy path, error cases, edge cases, integration
+- Test data: Required fixtures, mocks, test data
+- Dependencies: External services, databases, APIs to mock
+- Coverage targets: Functions/methods requiring tests
+
+### 5. Test Generation Strategy
+- Determine test generation approach for each file
+- Identify reusable test patterns from existing tests
+- Plan test data and fixture requirements
+- Define mocking strategy for dependencies
+- Specify expected test file structure
+
+## EXPECTED OUTPUT FORMAT
+
+Write comprehensive analysis to gemini-test-analysis.md:
+
+# Test Generation Analysis
+
+## 1. Implementation Context Summary
+- **Source Session**: {source_session_id}
+- **Implemented Features**: {feature_summary}
+- **Changed Files**: {list_of_implementation_files}
+- **Tech Stack**: {technologies_used}
+
+## 2. Test Coverage Assessment
+- **Existing Tests**: {count} files
+- **Missing Tests**: {count} files
+- **Coverage Percentage**: {percentage}%
+- **Priority Breakdown**:
+  - High Priority: {count} files (core business logic)
+  - Medium Priority: {count} files (utilities, helpers)
+  - Low Priority: {count} files (configuration, constants)
+
+## 3. Existing Test Pattern Analysis
+- **Test Framework**: {framework_name_and_version}
+- **File Naming Convention**: {pattern}
+- **Test Structure**: {describe_it_or_other}
+- **Assertion Style**: {expect_assert_should}
+- **Mocking Strategy**: {mocking_framework_and_patterns}
+- **Setup/Teardown**: {beforeEach_afterEach_patterns}
+- **Test Data**: {fixtures_factories_builders}
+
+## 4. Test Requirements by File
+
+### File: {implementation_file_path}
+**Test File**: {suggested_test_file_path}
+**Priority**: {high|medium|low}
+
+#### Scope
+- {description_of_what_needs_testing}
+
+#### Test Scenarios
+1. **Happy Path Tests**
+   - {scenario_1}
+   - {scenario_2}
+
+2. **Error Handling Tests**
+   - {error_scenario_1}
+   - {error_scenario_2}
+
+3. **Edge Case Tests**
+   - {edge_case_1}
+   - {edge_case_2}
+
+4. **Integration Tests** (if applicable)
+   - {integration_scenario_1}
+   - {integration_scenario_2}
+
+#### Test Data & Fixtures
+- {required_test_data}
+- {required_mocks}
+- {required_fixtures}
+
+#### Dependencies to Mock
+- {external_service_1}
+- {external_service_2}
+
+#### Coverage Targets
+- Function: {function_name} - {test_requirements}
+- Function: {function_name} - {test_requirements}
+
+---
+[Repeat for each missing test file]
+---
+
+## 5. Test Generation Strategy
+
+### Overall Approach
+- {strategy_description}
+
+### Test Generation Order
+1. {file_1} - {rationale}
+2. {file_2} - {rationale}
+3. {file_3} - {rationale}
+
+### Reusable Patterns
+- {pattern_1_from_existing_tests}
+- {pattern_2_from_existing_tests}
+
+### Test Data Strategy
+- {approach_to_test_data_and_fixtures}
+
+### Mocking Strategy
+- {approach_to_mocking_dependencies}
+
+### Quality Criteria
+- Code coverage target: {percentage}%
+- Test scenarios per function: {count}
+- Integration test coverage: {approach}
+
+## 6. Implementation Targets
+
+**Purpose**: Identify new test files to create
+
+**Format**: New test files only (no existing files to modify)
+
+**Test Files to Create**:
+1. **Target**: `tests/auth/TokenValidator.test.ts`
+   - **Type**: Create new test file
+   - **Purpose**: Test TokenValidator class
+   - **Scenarios**: 15 test cases covering validation logic, error handling, edge cases
+   - **Dependencies**: Mock JWT library, test fixtures for tokens
+
+2. **Target**: `tests/middleware/errorHandler.test.ts`
+   - **Type**: Create new test file
+   - **Purpose**: Test error handling middleware
+   - **Scenarios**: 8 test cases for different error types and response formats
+   - **Dependencies**: Mock Express req/res/next, error fixtures
+
+[List all test files to create]
+
+## 7. Success Metrics
+- **Test Coverage Goal**: {target_percentage}%
+- **Test Quality**: All scenarios covered (happy, error, edge, integration)
+- **Convention Compliance**: Follow existing test patterns
+- **Maintainability**: Clear test descriptions, reusable fixtures

.ccw/workflows/cli-templates/prompts/workflow-codex-feasibility-validation.txt

@@ -0,0 +1,176 @@
+Validate technical feasibility and identify implementation risks for proposed solution design.
+
+## CORE CHECKLIST ⚡
+□ Read context-package.json and gemini-solution-design.md
+□ Assess complexity, validate technology choices
+□ Evaluate performance and security implications
+□ Focus on TECHNICAL FEASIBILITY and RISK ASSESSMENT
+□ Write output to specified .workflow/active/{session_id}/.process/ path
+
+## PREREQUISITE ANALYSIS
+
+### Required Input Files
+1. **context-package.json**: Task requirements, source files, tech stack
+2. **gemini-solution-design.md**: Proposed solution design and architecture
+3. **workflow-session.json**: Session state and context
+4. **CLAUDE.md**: Project standards and conventions
+
+### Analysis Dependencies
+- Review Gemini's proposed solution design
+- Validate against actual codebase capabilities
+- Assess implementation complexity realistically
+- Identify gaps between design and execution
+
+## REQUIRED VALIDATION
+
+### 1. Feasibility Assessment
+- **Complexity Rating**: Rate technical complexity (1-5 scale)
+  - 1: Trivial - straightforward implementation
+  - 2: Simple - well-known patterns
+  - 3: Moderate - some challenges
+  - 4: Complex - significant challenges
+  - 5: Very Complex - high risk, major unknowns
+
+- **Resource Requirements**: Estimate development effort
+  - Development time (hours/days/weeks)
+  - Required expertise level
+  - Infrastructure needs
+
+- **Technology Compatibility**: Validate proposed tech stack
+  - Framework version compatibility
+  - Library maturity and support
+  - Integration with existing systems
+
+### 2. Risk Analysis
+- **Implementation Risks**: Technical challenges and blockers
+  - Unknown implementation patterns
+  - Missing capabilities or APIs
+  - Breaking changes to existing code
+
+- **Integration Challenges**: System integration concerns
+  - Data format compatibility
+  - API contract changes
+  - Dependency conflicts
+
+- **Performance Concerns**: Performance and scalability risks
+  - Resource consumption (CPU, memory, I/O)
+  - Latency and throughput impact
+  - Caching and optimization needs
+
+- **Security Concerns**: Security vulnerabilities and threats
+  - Authentication/authorization gaps
+  - Data exposure risks
+  - Compliance violations
+
+### 3. Implementation Validation
+- **Development Approach**: Validate proposed implementation strategy
+  - Verify module dependency order
+  - Assess incremental development feasibility
+  - Evaluate testing approach
+
+- **Quality Standards**: Validate quality requirements
+  - Test coverage achievability
+  - Performance benchmark realism
+  - Documentation completeness
+
+- **Maintenance Implications**: Long-term sustainability
+  - Code maintainability assessment
+  - Technical debt evaluation
+  - Evolution and extensibility
+
+### 4. Code Target Verification
+Review Gemini's proposed code targets:
+- **Validate existing targets**: Confirm file:function:lines exist
+- **Assess new file targets**: Evaluate necessity and placement
+- **Identify missing targets**: Suggest additional modification points
+- **Refine target specifications**: Provide more precise line numbers if possible
+
+### 5. Recommendations
+- **Must-Have Requirements**: Critical requirements for success
+- **Optimization Opportunities**: Performance and quality improvements
+- **Security Controls**: Essential security measures
+- **Risk Mitigation**: Strategies to reduce identified risks
+
+## OUTPUT REQUIREMENTS
+
+### Output File
+**Path**: `.workflow/active/{session_id}/.process/codex-feasibility-validation.md`
+**Format**: Follow structure from `~/.ccw/workflows/cli-templates/prompts/workflow/analysis-results-structure.txt`
+
+### Required Sections
+Focus on these sections from the template:
+- Executive Summary (with Codex perspective)
+- Current State Analysis (validation findings)
+- Implementation Strategy (feasibility assessment)
+- Solution Optimization (risk mitigation)
+- Confidence Scores (technical feasibility focus)
+
+### Content Guidelines
+- ✅ Focus on technical feasibility and risk assessment
+- ✅ Verify code targets from Gemini's design
+- ✅ Provide concrete risk mitigation strategies
+- ✅ Quantify complexity and effort estimates
+- ❌ Do NOT create task breakdowns
+- ❌ Do NOT provide step-by-step implementation guides
+- ❌ Do NOT include code examples
+
+## VALIDATION METHODOLOGY
+
+### Complexity Scoring
+Rate each aspect on 1-5 scale:
+- Technical Complexity
+- Integration Complexity
+- Performance Risk
+- Security Risk
+- Maintenance Burden
+
+### Risk Classification
+- **LOW**: Minor issues, easily addressable
+- **MEDIUM**: Manageable challenges with clear mitigation
+- **HIGH**: Significant concerns requiring major mitigation
+- **CRITICAL**: Fundamental viability threats
+
+### Feasibility Judgment
+- **PROCEED**: Technically feasible with acceptable risk
+- **PROCEED_WITH_MODIFICATIONS**: Feasible but needs adjustments
+- **RECONSIDER**: High risk, major changes needed
+- **REJECT**: Not feasible with current approach
+
+## CONTEXT INTEGRATION
+
+### Gemini Analysis Integration
+- Review proposed architecture and design decisions
+- Validate assumptions and technology choices
+- Cross-check code targets against actual codebase
+- Assess realism of performance targets
+
+### Codebase Reality Check
+- Verify existing code capabilities
+- Identify actual technical constraints
+- Assess team skill compatibility
+- Evaluate infrastructure readiness
+
+### Session Context
+- Consider session history and previous decisions
+- Align with project architecture standards
+- Respect existing patterns and conventions
+
+## EXECUTION MODE
+
+**Mode**: Analysis with write permission for output file
+**CLI Tool**: Codex with --skip-git-repo-check -s danger-full-access
+**Timeout**: 60-90 minutes for complex tasks
+**Output**: Single file codex-feasibility-validation.md
+**Trigger**: Only for complex tasks (>6 modules)
+
+## VERIFICATION CHECKLIST ✓
+□ context-package.json and gemini-solution-design.md read
+□ Complexity rated on 1-5 scale with justification
+□ All risk categories assessed (technical, integration, performance, security)
+□ Code targets verified and refined
+□ Risk mitigation strategies provided
+□ Resource requirements estimated
+□ Final feasibility judgment (PROCEED/RECONSIDER/REJECT)
+□ Output written to .workflow/active/{session_id}/.process/codex-feasibility-validation.md
+
+Focus: Technical feasibility validation with realistic risk assessment and mitigation strategies.

.ccw/workflows/cli-templates/prompts/workflow-gemini-solution-design.txt

@@ -0,0 +1,131 @@
+Analyze and design optimal solution with comprehensive architecture evaluation and design decisions.
+
+## CORE CHECKLIST ⚡
+□ Read context-package.json to understand task requirements, source files, tech stack
+□ Analyze current architecture patterns and code structure
+□ Propose solution design with key decisions and rationale
+□ Focus on SOLUTION IMPROVEMENTS and KEY DESIGN DECISIONS
+□ Write output to specified .workflow/active/{session_id}/.process/ path
+
+## ANALYSIS PRIORITY
+
+### Source Hierarchy
+1. **PRIMARY**: Individual role analysis.md files (system-architect, ui-designer, data-architect, etc.)
+   - Technical details and implementation considerations
+   - Architecture Decision Records (ADRs)
+   - Design decision context and rationale
+
+2. **SECONDARY**: role analysis documents
+   - Integrated requirements across roles
+   - Cross-role alignment and dependencies
+   - Unified feature specifications
+
+3. **REFERENCE**: guidance-specification.md
+   - Discussion context and background
+   - Initial problem framing
+
+## REQUIRED ANALYSIS
+
+### 1. Current State Assessment
+- Identify existing architectural patterns and code structure
+- Map integration points and dependencies
+- Evaluate technical debt and pain points
+- Assess framework compatibility and constraints
+
+### 2. Solution Design
+- Propose core architecture principles and approach
+- Design component architecture and data flow
+- Specify API contracts and integration strategy
+- Define technology stack with justification
+
+### 3. Key Design Decisions
+For each critical decision:
+- **Decision**: What is being decided
+- **Rationale**: Why this approach
+- **Alternatives Considered**: Other options and their tradeoffs
+- **Impact**: Implications on architecture, performance, maintainability
+
+Minimum 2 key decisions required.
+
+### 4. Code Modification Targets
+Identify specific code locations for changes:
+- **Existing files**: `file:function:lines` format (e.g., `src/auth/login.ts:validateUser:45-52`)
+- **New files**: `file` only (e.g., `src/auth/PasswordReset.ts`)
+- **Unknown lines**: `file:function:*` (e.g., `src/auth/service.ts:refreshToken:*`)
+
+For each target:
+- Type: Modify existing | Create new
+- Modification/Purpose: What changes needed
+- Rationale: Why this target
+
+### 5. Critical Insights
+- Strengths: What works well in current/proposed design
+- Gaps: Missing capabilities or concerns
+- Risks: Technical, integration, performance, security
+- Optimization Opportunities: Performance, security, code quality
+
+### 6. Feasibility Assessment
+- Technical Complexity: Rating and analysis
+- Performance Impact: Expected characteristics
+- Resource Requirements: Development effort
+- Maintenance Burden: Ongoing considerations
+
+## OUTPUT REQUIREMENTS
+
+### Output File
+**Path**: `.workflow/active/{session_id}/.process/gemini-solution-design.md`
+**Format**: Follow structure from `~/.ccw/workflows/cli-templates/prompts/workflow/analysis-results-structure.txt`
+
+### Required Sections
+- Executive Summary with feasibility score
+- Current State Analysis
+- Proposed Solution Design with 2+ key decisions
+- Implementation Strategy with code targets
+- Solution Optimization (performance, security, quality)
+- Critical Success Factors
+- Confidence Scores with recommendation
+
+### Content Guidelines
+- ✅ Focus on solution improvements and key design decisions
+- ✅ Include rationale, alternatives, and tradeoffs for decisions
+- ✅ Provide specific code targets in correct format
+- ✅ Quantify assessments with scores (X/5)
+- ❌ Do NOT create task lists or implementation steps
+- ❌ Do NOT include code examples or snippets
+- ❌ Do NOT create project management timelines
+
+## CONTEXT INTEGRATION
+
+### Session Context
+- Load context-package.json for task requirements
+- Reference workflow-session.json for session state
+- Review CLAUDE.md for project standards
+
+### Brainstorm Context
+If brainstorming artifacts exist:
+- Prioritize individual role analysis.md files
+- Use role analysis documents for integrated view
+- Reference guidance-specification.md for context
+
+### Codebase Context
+- Identify similar patterns in existing code
+- Evaluate success/failure of current approaches
+- Ensure consistency with project architecture
+
+## EXECUTION MODE
+
+**Mode**: Analysis with write permission for output file
+**CLI Tool**: Gemini wrapper with --approval-mode yolo
+**Timeout**: 40-60 minutes based on complexity
+**Output**: Single file gemini-solution-design.md
+
+## VERIFICATION CHECKLIST ✓
+□ context-package.json read and analyzed
+□ All 7 required sections present in output
+□ 2+ key design decisions with rationale and alternatives
+□ Code targets specified in correct format
+□ Feasibility scores provided (X/5)
+□ Final recommendation (PROCEED/RECONSIDER/REJECT)
+□ Output written to .workflow/active/{session_id}/.process/gemini-solution-design.md
+
+Focus: Comprehensive solution design emphasizing architecture decisions and critical insights.

.ccw/workflows/cli-templates/prompts/workflow-impl-plan-template.txt

@@ -0,0 +1,286 @@
+IMPL_PLAN.md Template - Implementation Plan Document Structure
+
+## Document Frontmatter
+
+```yaml
+---
+identifier: WFS-{session-id}
+source: "User requirements" | "File: path" | "Issue: ISS-001"
+analysis: .workflow/active//{session-id}/.process/ANALYSIS_RESULTS.md
+artifacts: .workflow/active//{session-id}/.brainstorming/
+context_package: .workflow/active//{session-id}/.process/context-package.json  # CCW smart context
+workflow_type: "standard | tdd | design"  # Indicates execution model
+verification_history:  # CCW quality gates
+  concept_verify: "passed | skipped | pending"
+  action_plan_verify: "pending"
+phase_progression: "brainstorm → context → analysis → concept_verify → planning"  # CCW workflow phases
+---
+```
+
+## Document Structure
+
+# Implementation Plan: {Project Title}
+
+## 1. Summary
+Core requirements, objectives, technical approach summary (2-3 paragraphs max).
+
+**Core Objectives**:
+- [Key objective 1]
+- [Key objective 2]
+
+**Technical Approach**:
+- [High-level approach]
+
+## 2. Context Analysis
+
+### CCW Workflow Context
+**Phase Progression**:
+- ✅ Phase 1: Brainstorming (role analyses generated)
+- ✅ Phase 2: Context Gathering (context-package.json: {N} files, {M} modules analyzed)
+- ✅ Phase 3: Enhanced Analysis (ANALYSIS_RESULTS.md: Gemini/Qwen/Codex parallel insights)
+- ✅ Phase 4: Concept Verification ({X} clarifications answered, role analyses updated | skipped)
+- ⏳ Phase 5: Action Planning (current phase - generating IMPL_PLAN.md)
+
+**Quality Gates**:
+- concept-verify: ✅ Passed (0 ambiguities remaining) | ⏭️ Skipped (user decision) | ⏳ Pending
+- plan-verify: ⏳ Pending (recommended before /workflow:execute)
+
+**Context Package Summary**:
+- **Focus Paths**: {list key directories from context-package.json}
+- **Key Files**: {list primary files for modification}
+- **Module Depth Analysis**: {from get_modules_by_depth.sh output}
+- **Smart Context**: {total file count} files, {module count} modules, {dependency count} dependencies identified
+
+### Project Profile
+- **Type**: Greenfield/Enhancement/Refactor
+- **Scale**: User count, data volume, complexity
+- **Tech Stack**: Primary technologies
+- **Timeline**: Duration and milestones
+
+### Module Structure
+```
+[Directory tree showing key modules]
+```
+
+### Dependencies
+**Primary**: [Core libraries and frameworks]
+**APIs**: [External services]
+**Development**: [Testing, linting, CI/CD tools]
+
+### Patterns & Conventions
+- **Architecture**: [Key patterns like DI, Event-Driven]
+- **Component Design**: [Design patterns]
+- **State Management**: [State strategy]
+- **Code Style**: [Naming, TypeScript coverage]
+
+## 3. Brainstorming Artifacts Reference
+
+### Artifact Usage Strategy
+**Primary Reference (role analyses)**:
+- **What**: Role-specific analyses from brainstorming providing multi-perspective insights
+- **When**: Every task references relevant role analyses for requirements and design decisions
+- **How**: Extract requirements, architecture decisions, UI/UX patterns from applicable role documents
+- **Priority**: Collective authoritative source - multiple role perspectives provide comprehensive coverage
+- **CCW Value**: Maintains role-specific expertise while enabling cross-role integration during planning
+
+**Context Intelligence (context-package.json)**:
+- **What**: Smart context gathered by CCW's context-gather phase
+- **Content**: Focus paths, dependency graph, existing patterns, module structure
+- **Usage**: Tasks load this via `flow_control.preparatory_steps` for environment setup
+- **CCW Value**: Automated intelligent context discovery replacing manual file exploration
+
+**Technical Analysis (ANALYSIS_RESULTS.md)**:
+- **What**: Gemini/Qwen/Codex parallel analysis results
+- **Content**: Optimization strategies, risk assessment, architecture review, implementation patterns
+- **Usage**: Referenced in task planning for technical guidance and risk mitigation
+- **CCW Value**: Multi-model parallel analysis providing comprehensive technical intelligence
+
+### Integrated Specifications (Highest Priority)
+- **role analyses**: Comprehensive implementation blueprint
+  - Contains: Architecture design, UI/UX guidelines, functional/non-functional requirements, implementation roadmap, risk assessment
+
+### Supporting Artifacts (Reference)
+- **guidance-specification.md**: Role-specific discussion points and analysis framework
+- **system-architect/analysis.md**: Detailed architecture specifications
+- **ui-designer/analysis.md**: Layout and component specifications
+- **product-manager/analysis.md**: Product vision and user stories
+
+**Artifact Priority in Development**:
+1. role analyses (primary reference for all tasks)
+2. context-package.json (smart context for execution environment)
+3. ANALYSIS_RESULTS.md (technical analysis and optimization strategies)
+4. Role-specific analyses (fallback for detailed specifications)
+
+## 4. Implementation Strategy
+
+### Execution Strategy
+**Execution Model**: [Sequential | Parallel | Phased | TDD Cycles]
+
+**Rationale**: [Why this execution model fits the project]
+
+**Parallelization Opportunities**:
+- [List independent workstreams]
+
+**Serialization Requirements**:
+- [List critical dependencies]
+
+### Architectural Approach
+**Key Architecture Decisions**:
+- [ADR references from role analyses]
+- [Justification for architecture patterns]
+
+**Integration Strategy**:
+- [How modules communicate]
+- [State management approach]
+
+### Key Dependencies
+**Task Dependency Graph**:
+```
+[High-level dependency visualization]
+```
+
+**Critical Path**: [Identify bottleneck tasks]
+
+### Testing Strategy
+**Testing Approach**:
+- Unit testing: [Tools, scope]
+- Integration testing: [Key integration points]
+- E2E testing: [Critical user flows]
+
+**Coverage Targets**:
+- Lines: ≥70%
+- Functions: ≥70%
+- Branches: ≥65%
+
+**Quality Gates**:
+- [CI/CD gates]
+- [Performance budgets]
+
+## 5. Task Breakdown Summary
+
+### Task Count
+**{N} tasks** (flat hierarchy | two-level hierarchy, sequential | parallel execution)
+
+### Task Structure
+- **IMPL-1**: [Main task title]
+- **IMPL-2**: [Main task title]
+...
+
+### Complexity Assessment
+- **High**: [List with rationale]
+- **Medium**: [List]
+- **Low**: [List]
+
+### Dependencies
+[Reference Section 4.3 for dependency graph]
+
+**Parallelization Opportunities**:
+- [Specific task groups that can run in parallel]
+
+## 6. Implementation Plan (Detailed Phased Breakdown)
+
+### Execution Strategy
+
+**Phase 1 (Weeks 1-2): [Phase Name]**
+- **Tasks**: IMPL-1, IMPL-2
+- **Deliverables**:
+  - [Specific deliverable 1]
+  - [Specific deliverable 2]
+- **Success Criteria**:
+  - [Measurable criterion]
+
+**Phase 2 (Weeks 3-N): [Phase Name]**
+...
+
+### Resource Requirements
+
+**Development Team**:
+- [Team composition and skills]
+
+**External Dependencies**:
+- [Third-party services, APIs]
+
+**Infrastructure**:
+- [Development, staging, production environments]
+
+## 7. Risk Assessment & Mitigation
+
+| Risk | Impact | Probability | Mitigation Strategy | Owner |
+|------|--------|-------------|---------------------|-------|
+| [Risk description] | High/Med/Low | High/Med/Low | [Strategy] | [Role] |
+
+**Critical Risks** (High impact + High probability):
+- [Risk 1]: [Detailed mitigation plan]
+
+**Monitoring Strategy**:
+- [How risks will be monitored]
+
+## 8. Success Criteria
+
+**Functional Completeness**:
+- [ ] All requirements from role analyses implemented
+- [ ] All acceptance criteria from task.json files met
+
+**Technical Quality**:
+- [ ] Test coverage ≥70%
+- [ ] Bundle size within budget
+- [ ] Performance targets met
+
+**Operational Readiness**:
+- [ ] CI/CD pipeline operational
+- [ ] Monitoring and logging configured
+- [ ] Documentation complete
+
+**Business Metrics**:
+- [ ] [Key business metrics from role analyses]
+
+## Template Usage Guidelines
+
+### When Generating IMPL_PLAN.md
+
+1. **Fill Frontmatter Variables**:
+   - Replace {session-id} with actual session ID
+   - Set workflow_type based on planning phase
+   - Update verification_history based on concept-verify results
+
+2. **Populate CCW Workflow Context**:
+   - Extract file/module counts from context-package.json
+   - Document phase progression based on completed workflow steps
+   - Update quality gate status (passed/skipped/pending)
+
+3. **Extract from Analysis Results**:
+   - Core objectives from ANALYSIS_RESULTS.md
+   - Technical approach and architecture decisions
+   - Risk assessment and mitigation strategies
+
+4. **Reference Brainstorming Artifacts**:
+   - List detected artifacts with correct paths
+   - Document artifact priority and usage strategy
+   - Map artifacts to specific tasks based on domain
+
+5. **Define Implementation Strategy**:
+   - Choose execution model (sequential/parallel/phased)
+   - Identify parallelization opportunities
+   - Document critical path and dependencies
+
+6. **Break Down Tasks**:
+   - List all task IDs and titles
+   - Assess complexity (high/medium/low)
+   - Create dependency graph visualization
+
+7. **Set Success Criteria**:
+   - Extract from role analyses
+   - Include measurable metrics
+   - Define quality gates
+
+### Validation Checklist
+
+Before finalizing IMPL_PLAN.md:
+- [ ] All frontmatter fields populated correctly
+- [ ] CCW workflow context reflects actual phase progression
+- [ ] Brainstorming artifacts correctly referenced
+- [ ] Task breakdown matches generated task JSONs
+- [ ] Dependencies are acyclic and logical
+- [ ] Success criteria are measurable
+- [ ] Risk assessment includes mitigation strategies
+- [ ] All {placeholder} variables replaced with actual values

.ccw/workflows/cli-templates/prompts/workflow-skill-conflict-patterns.txt

@@ -0,0 +1,94 @@
+Template for generating conflict-patterns.md
+
+## Purpose
+Document recurring conflict patterns across workflow sessions with resolutions.
+
+## File Location
+`.claude/skills/workflow-progress/conflict-patterns.md`
+
+## Update Strategy
+- **Incremental mode**: Add new conflicts, update frequency counters for existing patterns
+- **Full mode**: Regenerate entire conflict analysis from all sessions
+
+## Structure
+
+```markdown
+# Workflow Conflict Patterns
+
+## Architecture Conflicts
+
+### {Conflict_Pattern_Title}
+**Pattern**: {concise_pattern_description}
+**Sessions**: {session_id_1}, {session_id_2}
+**Resolution**: {resolution_strategy}
+
+**Code Impact**:
+- Modified: {file_path_1}, {file_path_2}
+- Added: {file_path_3}
+- Tests: {test_file_path}
+
+**Frequency**: {count} sessions
+**Severity**: {high|medium|low}
+
+---
+
+## Dependency Conflicts
+
+### {Conflict_Pattern_Title}
+**Pattern**: {concise_pattern_description}
+**Sessions**: {session_id_list}
+**Resolution**: {resolution_strategy}
+
+**Package Changes**:
+- Updated: {package_name}@{version}
+- Locked: {dependency_name}
+
+**Frequency**: {count} sessions
+**Severity**: {high|medium|low}
+
+---
+
+## Testing Conflicts
+
+### {Conflict_Pattern_Title}
+...
+
+---
+
+## Performance Conflicts
+
+### {Conflict_Pattern_Title}
+...
+```
+
+## Data Sources
+- IMPL_PLAN summaries: `.workflow/.archives/{session_id}/IMPL_PLAN.md`
+- Context packages: `.workflow/.archives/{session_id}/.process/context-package.json` (reference only)
+- Session lessons: `manifest.json` -> `archives[].lessons.challenges`
+
+## Conflict Identification (Use CCW CLI)
+
+**Command Pattern**:
+```bash
+ccw cli -p "
+PURPOSE: Identify conflict patterns from workflow sessions
+TASK: • Extract conflicts from IMPL_PLAN and lessons • Group by type (architecture/dependencies/testing/performance) • Identify recurring patterns (same conflict in different sessions) • Link resolutions to specific sessions
+MODE: analysis
+CONTEXT: @.workflow/.archives/*/IMPL_PLAN.md @.workflow/.archives/manifest.json
+EXPECTED: Conflict patterns with frequency and resolution
+CONSTRAINTS: analysis=READ-ONLY
+" --tool gemini --mode analysis --rule workflow-skill-aggregation --cd .workflow/.archives
+```
+
+**Pattern Grouping**:
+- **Architecture**: Design conflicts, incompatible strategies, interface mismatches
+- **Dependencies**: Version conflicts, library incompatibilities, package issues
+- **Testing**: Mock data inconsistencies, test environment issues, coverage gaps
+- **Performance**: Bottlenecks, optimization conflicts, resource issues
+
+## Formatting Rules
+- Sort by frequency within each category
+- Include code impact for traceability
+- Mark high-frequency patterns (3+ sessions) as "RECURRING"
+- Keep resolution descriptions actionable
+- Use relative paths for file references

.ccw/workflows/cli-templates/prompts/workflow-skill-lessons-learned.txt

@@ -0,0 +1,94 @@
+Template for generating lessons-learned.md
+
+## Purpose
+Aggregate lessons learned from workflow sessions, categorized by functional domain and severity.
+
+## File Location
+`.claude/skills/workflow-progress/lessons-learned.md`
+
+## Update Strategy
+- **Incremental mode**: Merge new session lessons into existing categories, update frequencies
+- **Full mode**: Regenerate entire lessons document from all sessions
+
+## Structure
+
+```markdown
+# Workflow Lessons Learned
+
+## Best Practices (Successes)
+
+### {Domain_Category}
+- {success_pattern_1} (sessions: {session_id_1}, {session_id_2})
+- {success_pattern_2} (sessions: {session_id_3})
+
+### {Domain_Category_2}
+...
+
+---
+
+## Known Challenges
+
+### High Priority
+- **{challenge_title}**: {description}
+  - Affected sessions: {session_id_1}, {session_id_2}
+  - Resolution: {resolution_strategy}
+
+### Medium Priority
+- **{challenge_title}**: {description}
+  - Affected sessions: {session_id_3}
+  - Resolution: {resolution_strategy}
+
+### Low Priority
+...
+
+---
+
+## Watch Patterns
+
+### Critical (3+ sessions)
+1. **{pattern_name}**: {description}
+   - Frequency: {count} sessions
+   - Affected: {session_list}
+   - Mitigation: {mitigation_strategy}
+
+### High Priority (2 sessions)
+...
+
+### Normal (1 session)
+...
+```
+
+## Data Sources
+- Lessons: `manifest.json` -> `archives[].lessons.{successes|challenges|watch_patterns}`
+- Session metadata: `.workflow/.archives/{session_id}/workflow-session.json`
+
+## Aggregation Rules (Use CCW CLI)
+
+**Command Pattern**:
+```bash
+ccw cli -p "
+PURPOSE: Aggregate workflow lessons from session data
+TASK: • Group successes by functional domain • Categorize challenges by severity (HIGH/MEDIUM/LOW) • Identify watch patterns with frequency >= 2 • Mark CRITICAL patterns (3+ sessions)
+MODE: analysis
+CONTEXT: @.workflow/.archives/manifest.json
+EXPECTED: Aggregated lessons with frequency counts
+CONSTRAINTS: analysis=READ-ONLY
+" --tool gemini --mode analysis --rule workflow-skill-aggregation --cd .workflow/.archives
+```
+
+**Severity Classification**:
+- **HIGH**: Blocked development >4 hours OR repeated in 3+ sessions
+- **MEDIUM**: Required significant rework OR repeated in 2 sessions
+- **LOW**: Minor issues resolved quickly
+
+**Pattern Identification**:
+- Successes in 3+ sessions → "Best Practices"
+- Challenges repeated 2+ times → "Known Issues"
+- Watch patterns frequency >= 2 → "High Priority Warnings"
+- Watch patterns frequency >= 3 → "CRITICAL"
+
+## Formatting Rules
+- Sort by frequency (most common first)
+- Include session references for traceability
+- Use bold for challenge titles
+- Keep descriptions concise but actionable

.ccw/workflows/cli-templates/protocols/analysis-protocol.md

@@ -0,0 +1,119 @@
+# Analysis Mode Protocol
+
+## Mode Definition
+**Mode**: `analysis` (READ-ONLY)
+## Prompt Structure
+
+```
+PURPOSE: [development goal]
+TASK: [specific implementation task]
+MODE: [auto|write]
+CONTEXT: [file patterns]
+EXPECTED: [deliverables]
+RULES: [templates | additional constraints]
+```
+## Operation Boundaries
+
+### ALLOWED Operations
+- **READ**: All CONTEXT files and analyze content
+- **ANALYZE**: Code patterns, architecture, dependencies
+- **GENERATE**: Text output, insights, recommendations
+- **DOCUMENT**: Analysis results in output response only
+
+### FORBIDDEN Operations
+- **NO FILE CREATION**: Cannot create any files on disk
+- **NO FILE MODIFICATION**: Cannot modify existing files
+- **NO FILE DELETION**: Cannot delete any files
+- **NO DIRECTORY OPERATIONS**: Cannot create/modify directories
+
+**CRITICAL**: Absolutely NO file system operations - OUTPUT ONLY
+
+## Execution Flow
+
+1. **Parse** all 6 fields (PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES)
+2. **Read** and analyze CONTEXT files thoroughly
+3. **Identify** patterns, issues, and dependencies
+4. **Generate** insights and recommendations
+5. **Validate** EXPECTED deliverables met
+6. **Output** structured analysis (text response only)
+
+## Core Requirements
+
+**ALWAYS**:
+- Analyze ALL CONTEXT files completely
+- Apply RULES (templates + constraints) exactly
+- Provide code evidence with `file:line` references
+- List all related/analyzed files at output beginning
+- Match EXPECTED deliverables precisely
+
+**NEVER**:
+- Assume behavior without code verification
+- Ignore CONTEXT file patterns
+- Skip RULES or templates
+- Make unsubstantiated claims
+- Create/modify/delete any files
+
+## RULES Processing
+
+- Parse RULES field to extract template content and constraints
+- Recognize `|` as separator: `template content | additional constraints`
+- Apply ALL template guidelines as mandatory
+- Treat rule violations as task failures
+
+## Error Handling
+
+**File Not Found**: Report missing files, continue with available, note in output
+**Invalid CONTEXT Pattern**: Report invalid pattern, request correction, do not guess
+
+## Quality Standards
+
+- **Thoroughness**: Analyze ALL files, check cross-file patterns, quantify metrics
+- **Evidence-Based**: Quote code with `file:line`, link patterns, support claims with examples
+- **Actionable**: Clear recommendations, prioritized by impact, incremental changes
+
+---
+
+## Output Format
+
+### Format Priority
+
+**If template defines output format** → Follow template format EXACTLY
+
+**If template has no format** → Use default format below
+
+### Default Analysis Output
+
+```markdown
+# Analysis: [TASK Title]
+
+## Related Files
+- `path/to/file1.ext` - [Brief description of relevance]
+- `path/to/file2.ext` - [Brief description of relevance]
+
+## 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
+
+**Format**: `path/to/file:line_number`
+**Example**: `src/auth/jwt.ts:45` - Authentication uses deprecated algorithm
+
+### Quality Checklist
+
+- [ ] All CONTEXT files analyzed
+- [ ] Code evidence with `file:line` references
+- [ ] Specific, actionable recommendations
+- [ ] No unsubstantiated claims
+- [ ] EXPECTED deliverables met

.ccw/workflows/cli-templates/protocols/write-protocol.md

@@ -0,0 +1,136 @@
+# Write Mode Protocol
+## Prompt Structure
+
+```
+PURPOSE: [development goal]
+TASK: [specific implementation task]
+MODE: [auto|write]
+CONTEXT: [file patterns]
+EXPECTED: [deliverables]
+RULES: [templates | additional constraints]
+```
+## Operation Boundaries
+
+### MODE: write
+- **READ**: All CONTEXT files and analyze content
+- **CREATE**: New files (documentation, code, configuration)
+- **MODIFY**: Existing files (update content, refactor code)
+- **DELETE**: Files when explicitly required
+
+**Restrictions**: Follow project conventions, cannot break existing functionality
+
+**Constraint**: Must test every change
+
+## Execution Flow
+
+### MODE: write
+1. **Parse** all 6 fields (PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES)
+2. **Read** CONTEXT files, find 3+ similar patterns
+3. **Plan** implementation following RULES
+4. **Execute** requested file operations
+5. **Validate** changes
+6. **Report** file changes
+
+## Core Requirements
+
+**ALWAYS**:
+- Study CONTEXT files - find 3+ similar patterns before implementing
+- Apply RULES exactly
+- Test continuously (auto mode)
+- Commit incrementally (auto mode)
+- Match project style exactly
+- List all created/modified files at output beginning
+
+**NEVER**:
+- Make assumptions without code verification
+- Ignore existing patterns
+- Skip tests (auto mode)
+- Use clever tricks over boring solutions
+- Break backward compatibility
+- Exceed 3 failed attempts without stopping
+
+
+**Three-Attempt Rule**: On 3rd failure, stop and report what attempted, what failed, root cause
+
+| Error Type | Response |
+|------------|----------|
+| Syntax/Type | Review → Fix → Re-run tests |
+| Runtime | Analyze stack → Add handling → Test |
+| Test Failure | Debug → Review setup → Fix |
+| Build Failure | Check messages → Fix incrementally |
+
+---
+
+## Output Format
+
+### Format Priority
+
+**If template defines output format** → Follow template format EXACTLY
+
+**If template has no format** → Use default format below
+
+### Task Implementation
+
+```markdown
+# Implementation: [TASK Title]
+
+## Changes
+- Created: `path/to/file1.ext` (X lines)
+- Modified: `path/to/file2.ext` (+Y/-Z lines)
+- Deleted: `path/to/file3.ext`
+
+## Summary
+[2-3 sentence overview]
+
+## Key Decisions
+1. [Decision] - Rationale and reference to similar pattern
+2. [Decision] - path/to/reference:line
+
+## Implementation Details
+[Evidence-based description with code references]
+
+## Testing
+- Tests written: X new tests
+- Tests passing: Y/Z tests
+
+## Validation
+✅ Tests: X passing
+✅ Build: Success
+
+## Next Steps
+[Recommendations if any]
+```
+
+### Partial Completion
+
+```markdown
+# Task Status: Partially Completed
+
+## Completed
+- [What worked]
+- Files: `path/to/completed.ext`
+
+## Blocked
+- **Issue**: [What failed]
+- **Root Cause**: [Analysis]
+- **Attempted**: [Solutions tried - attempt X of 3]
+
+## Required
+[What's needed to proceed]
+
+## Recommendation
+[Suggested next steps]
+```
+
+### Code References
+
+**Format**: `path/to/file:line_number`
+**Example**: `src/auth/jwt.ts:45` - Implemented following pattern from `src/auth/session.ts:78`
+
+### Quality Checklist
+
+- [ ] All tests pass
+- [ ] Build succeeds
+- [ ] All EXPECTED deliverables met
+- [ ] Code follows existing patterns
+- [ ] File changes listed at beginning

.ccw/workflows/cli-templates/schemas/conflict-resolution-schema.json

@@ -0,0 +1,151 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Conflict Resolution Schema",
+  "description": "Schema for conflict detection, strategy generation, and resolution output",
+
+  "type": "object",
+  "required": ["conflicts", "summary"],
+  "properties": {
+    "conflicts": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "brief", "severity", "category", "strategies", "recommended"],
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^CON-\\d{3}$",
+            "description": "Conflict ID (CON-001, CON-002, ...)"
+          },
+          "brief": {
+            "type": "string",
+            "description": "一句话冲突摘要（中文）"
+          },
+          "severity": {
+            "enum": ["Critical", "High", "Medium"],
+            "description": "冲突严重程度"
+          },
+          "category": {
+            "enum": ["Architecture", "API", "Data", "Dependency", "ModuleOverlap"],
+            "description": "冲突类型"
+          },
+          "affected_files": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "受影响的文件路径"
+          },
+          "description": {
+            "type": "string",
+            "description": "详细冲突描述"
+          },
+          "impact": {
+            "type": "object",
+            "properties": {
+              "scope": { "type": "string", "description": "影响的模块/组件" },
+              "compatibility": { "enum": ["Yes", "No", "Partial"] },
+              "migration_required": { "type": "boolean" },
+              "estimated_effort": { "type": "string", "description": "人天估计" }
+            }
+          },
+          "overlap_analysis": {
+            "type": "object",
+            "description": "仅当 category=ModuleOverlap 时需要",
+            "properties": {
+              "new_module": {
+                "type": "object",
+                "properties": {
+                  "name": { "type": "string" },
+                  "scenarios": { "type": "array", "items": { "type": "string" } },
+                  "responsibilities": { "type": "string" }
+                }
+              },
+              "existing_modules": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "file": { "type": "string" },
+                    "name": { "type": "string" },
+                    "scenarios": { "type": "array", "items": { "type": "string" } },
+                    "overlap_scenarios": { "type": "array", "items": { "type": "string" } },
+                    "responsibilities": { "type": "string" }
+                  }
+                }
+              }
+            }
+          },
+          "strategies": {
+            "type": "array",
+            "minItems": 2,
+            "maxItems": 4,
+            "items": {
+              "type": "object",
+              "required": ["name", "approach", "complexity", "risk", "effort", "pros", "cons"],
+              "properties": {
+                "name": { "type": "string", "description": "策略名称（中文）" },
+                "approach": { "type": "string", "description": "实现方法简述" },
+                "complexity": { "enum": ["Low", "Medium", "High"] },
+                "risk": { "enum": ["Low", "Medium", "High"] },
+                "effort": { "type": "string", "description": "时间估计" },
+                "pros": { "type": "array", "items": { "type": "string" }, "description": "优点" },
+                "cons": { "type": "array", "items": { "type": "string" }, "description": "缺点" },
+                "clarification_needed": {
+                  "type": "array",
+                  "items": { "type": "string" },
+                  "description": "需要用户澄清的问题（尤其是 ModuleOverlap）"
+                },
+                "modifications": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "required": ["file", "section", "change_type", "old_content", "new_content", "rationale"],
+                    "properties": {
+                      "file": { "type": "string", "description": "相对项目根目录的完整路径" },
+                      "section": { "type": "string", "description": "Markdown heading 用于定位" },
+                      "change_type": { "enum": ["update", "add", "remove"] },
+                      "old_content": { "type": "string", "description": "原始内容片段（20-100字符，用于唯一匹配）" },
+                      "new_content": { "type": "string", "description": "修改后的内容" },
+                      "rationale": { "type": "string", "description": "修改理由" }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "recommended": {
+            "type": "integer",
+            "minimum": 0,
+            "description": "推荐策略索引（0-based）"
+          },
+          "modification_suggestions": {
+            "type": "array",
+            "minItems": 2,
+            "maxItems": 5,
+            "items": { "type": "string" },
+            "description": "自定义处理建议（2-5条，中文）"
+          }
+        }
+      }
+    },
+    "summary": {
+      "type": "object",
+      "required": ["total", "critical", "high", "medium"],
+      "properties": {
+        "total": { "type": "integer" },
+        "critical": { "type": "integer" },
+        "high": { "type": "integer" },
+        "medium": { "type": "integer" }
+      }
+    }
+  },
+
+  "_quality_standards": {
+    "modifications": [
+      "old_content: 20-100字符，确保 Edit 工具能唯一匹配",
+      "new_content: 保持 markdown 格式",
+      "change_type: update(替换), add(插入), remove(删除)"
+    ],
+    "user_facing_text": "brief, name, pros, cons, modification_suggestions 使用中文",
+    "technical_fields": "severity, category, complexity, risk 使用英文"
+  }
+}

.ccw/workflows/cli-templates/schemas/debug-log-json-schema.json

@@ -0,0 +1,127 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Debug Log Entry Schema",
+  "description": "NDJSON log entry for hypothesis-driven debugging workflow",
+  "type": "object",
+  "required": [
+    "sessionId",
+    "runId",
+    "hypothesisId",
+    "location",
+    "message",
+    "data",
+    "timestamp"
+  ],
+  "properties": {
+    "sessionId": {
+      "type": "string",
+      "pattern": "^DBG-[a-z0-9-]+-\\d{4}-\\d{2}-\\d{2}$",
+      "description": "Debug session identifier (e.g., 'DBG-stack-length-not-found-2025-12-18')"
+    },
+    "runId": {
+      "type": "string",
+      "pattern": "^run-\\d+$",
+      "description": "Reproduction run number (e.g., 'run-1', 'run-2')"
+    },
+    "hypothesisId": {
+      "type": "string",
+      "pattern": "^H\\d+$",
+      "description": "Hypothesis identifier being tested (e.g., 'H1', 'H2')"
+    },
+    "location": {
+      "type": "string",
+      "description": "Code location in format 'file:function:line' or 'file:line'"
+    },
+    "message": {
+      "type": "string",
+      "description": "Human-readable description of what's being logged"
+    },
+    "data": {
+      "type": "object",
+      "additionalProperties": true,
+      "description": "Captured values for hypothesis validation",
+      "properties": {
+        "keys_sample": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Sample of dictionary/object keys (first 30)"
+        },
+        "value": {
+          "description": "Captured value (any type)"
+        },
+        "expected_value": {
+          "description": "Expected value for comparison"
+        },
+        "actual_type": {
+          "type": "string",
+          "description": "Actual type of captured value"
+        },
+        "count": {
+          "type": "integer",
+          "description": "Count of items (for arrays/collections)"
+        },
+        "is_null": {
+          "type": "boolean",
+          "description": "Whether value is null/None"
+        },
+        "is_empty": {
+          "type": "boolean",
+          "description": "Whether collection is empty"
+        },
+        "comparison_result": {
+          "type": "string",
+          "enum": ["match", "mismatch", "partial_match"],
+          "description": "Result of value comparison"
+        }
+      }
+    },
+    "timestamp": {
+      "type": "integer",
+      "description": "Unix timestamp in milliseconds"
+    },
+    "severity": {
+      "type": "string",
+      "enum": ["debug", "info", "warning", "error"],
+      "default": "info",
+      "description": "Log severity level"
+    },
+    "stack_trace": {
+      "type": "string",
+      "description": "Stack trace if capturing exception context"
+    },
+    "parent_entry_id": {
+      "type": "string",
+      "description": "Reference to parent log entry for nested contexts"
+    }
+  },
+  "examples": [
+    {
+      "sessionId": "DBG-stack-length-not-found-2025-12-18",
+      "runId": "run-1",
+      "hypothesisId": "H1",
+      "location": "rmxprt_api/core/rmxprt_parameter.py:sync_from_machine:642",
+      "message": "Inspect stator keys from machine.to_dict and compare Stack Length vs Length",
+      "data": {
+        "keys_sample": ["Length", "Outer Diameter", "Inner Diameter", "Slot"],
+        "stack_length_value": "未找到",
+        "length_value": "120mm",
+        "comparison_result": "mismatch"
+      },
+      "timestamp": 1734523456789
+    },
+    {
+      "sessionId": "DBG-registered-zero-2025-12-18",
+      "runId": "run-1",
+      "hypothesisId": "H2",
+      "location": "rmxprt_api/utils/param_core.py:update_variables_from_result_model:670",
+      "message": "Check result parameters count and sample keys",
+      "data": {
+        "count": 0,
+        "is_empty": true,
+        "sections_parsed": ["Stator", "Rotor", "General"],
+        "expected_count": 145
+      },
+      "timestamp": 1734523457123
+    }
+  ]
+}

.ccw/workflows/cli-templates/schemas/diagnosis-json-schema.json

@@ -0,0 +1,234 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Diagnosis Context Schema",
+  "description": "Bug diagnosis results from cli-explore-agent for root cause analysis",
+  "type": "object",
+  "required": [
+    "symptom",
+    "root_cause",
+    "affected_files",
+    "reproduction_steps",
+    "fix_hints",
+    "dependencies",
+    "constraints",
+    "clarification_needs",
+    "_metadata"
+  ],
+  "properties": {
+    "symptom": {
+      "type": "object",
+      "required": ["description", "error_message"],
+      "properties": {
+        "description": {
+          "type": "string",
+          "description": "Human-readable description of the bug symptoms"
+        },
+        "error_message": {
+          "type": ["string", "null"],
+          "description": "Exact error message if available, null if no specific error"
+        },
+        "stack_trace": {
+          "type": ["string", "null"],
+          "description": "Stack trace excerpt if available"
+        },
+        "frequency": {
+          "type": "string",
+          "enum": ["always", "intermittent", "rare", "unknown"],
+          "description": "How often the bug occurs"
+        },
+        "user_impact": {
+          "type": "string",
+          "description": "How the bug affects end users"
+        }
+      },
+      "description": "Observable symptoms and error manifestation"
+    },
+    "root_cause": {
+      "type": "object",
+      "required": ["file", "issue", "confidence"],
+      "properties": {
+        "file": {
+          "type": "string",
+          "description": "File path where the root cause is located"
+        },
+        "line_range": {
+          "type": "string",
+          "description": "Line range containing the bug (e.g., '45-60')"
+        },
+        "function": {
+          "type": "string",
+          "description": "Function or method name containing the bug"
+        },
+        "issue": {
+          "type": "string",
+          "description": "Description of what's wrong in the code"
+        },
+        "confidence": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1,
+          "description": "Confidence score 0.0-1.0 (0.8+ high, 0.5-0.8 medium, <0.5 low)"
+        },
+        "introduced_by": {
+          "type": "string",
+          "description": "Commit hash or date when bug was introduced (if known)"
+        },
+        "category": {
+          "type": "string",
+          "enum": ["logic_error", "edge_case", "race_condition", "null_reference", "type_mismatch", "resource_leak", "validation", "integration", "configuration", "other"],
+          "description": "Bug category classification"
+        }
+      },
+      "description": "Root cause analysis with confidence score"
+    },
+    "affected_files": {
+      "type": "array",
+      "items": {
+        "oneOf": [
+          {"type": "string"},
+          {
+            "type": "object",
+            "required": ["path", "relevance"],
+            "properties": {
+              "path": {"type": "string", "description": "File path relative to project root"},
+              "relevance": {"type": "number", "minimum": 0, "maximum": 1, "description": "Relevance score 0.0-1.0 (0.7+ high, 0.5-0.7 medium, <0.5 low)"},
+              "rationale": {"type": "string", "description": "Brief explanation of why this file is affected from this diagnosis angle"},
+              "change_type": {
+                "type": "string",
+                "enum": ["fix_target", "needs_update", "test_coverage", "reference_only"],
+                "description": "Type of change needed for this file"
+              }
+            }
+          }
+        ]
+      },
+      "description": "Files affected by the bug. Prefer object format with relevance scores for synthesis prioritization."
+    },
+    "reproduction_steps": {
+      "type": "array",
+      "items": {"type": "string"},
+      "minItems": 1,
+      "description": "Step-by-step instructions to reproduce the bug"
+    },
+    "fix_hints": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["description", "approach"],
+        "properties": {
+          "description": {
+            "type": "string",
+            "description": "What needs to be fixed"
+          },
+          "approach": {
+            "type": "string",
+            "description": "Suggested fix approach with specific guidance"
+          },
+          "code_example": {
+            "type": "string",
+            "description": "Example code snippet showing the fix pattern"
+          },
+          "risk": {
+            "type": "string",
+            "enum": ["low", "medium", "high"],
+            "description": "Risk level of implementing this fix"
+          }
+        }
+      },
+      "description": "Actionable fix suggestions from this diagnosis angle"
+    },
+    "dependencies": {
+      "type": "string",
+      "description": "External and internal dependencies relevant to the bug"
+    },
+    "constraints": {
+      "type": "string",
+      "description": "Technical constraints and limitations affecting the fix"
+    },
+    "related_issues": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": ["similar_bug", "regression", "related_feature", "tech_debt"],
+            "description": "Relationship type"
+          },
+          "reference": {
+            "type": "string",
+            "description": "Issue ID, commit hash, or file reference"
+          },
+          "description": {
+            "type": "string",
+            "description": "Brief description of the relationship"
+          }
+        }
+      },
+      "description": "Related issues, regressions, or similar bugs found during diagnosis"
+    },
+    "clarification_needs": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["question", "context", "options"],
+        "properties": {
+          "question": {
+            "type": "string",
+            "description": "The clarification question to ask user"
+          },
+          "context": {
+            "type": "string",
+            "description": "Background context explaining why this clarification is needed"
+          },
+          "options": {
+            "type": "array",
+            "items": {"type": "string"},
+            "description": "Available options for user to choose from (2-4 options)"
+          }
+        }
+      },
+      "description": "Ambiguities requiring user input before fix planning"
+    },
+    "_metadata": {
+      "type": "object",
+      "required": ["timestamp", "bug_description", "source"],
+      "properties": {
+        "timestamp": {
+          "type": "string",
+          "format": "date-time",
+          "description": "ISO 8601 timestamp of diagnosis"
+        },
+        "bug_description": {
+          "type": "string",
+          "description": "Original bug description that triggered diagnosis"
+        },
+        "source": {
+          "type": "string",
+          "const": "cli-explore-agent",
+          "description": "Agent that performed diagnosis"
+        },
+        "diagnosis_angle": {
+          "type": "string",
+          "description": "Diagnosis angle (e.g., 'error-handling', 'dataflow', 'state-management')"
+        },
+        "diagnosis_index": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 4,
+          "description": "Diagnosis index (1-4) in parallel diagnosis set"
+        },
+        "total_diagnoses": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 4,
+          "description": "Total number of parallel diagnoses"
+        },
+        "duration_seconds": {
+          "type": "integer",
+          "description": "Diagnosis duration in seconds"
+        }
+      }
+    }
+  }
+}

.ccw/workflows/cli-templates/schemas/discovery-finding-schema.json

@@ -0,0 +1,219 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "discovery-finding-schema",
+  "title": "Discovery Finding Schema",
+  "description": "Schema for perspective-based issue discovery results",
+  "type": "object",
+  "required": ["perspective", "discovery_id", "analysis_timestamp", "cli_tool_used", "summary", "findings"],
+  "properties": {
+    "perspective": {
+      "type": "string",
+      "enum": ["bug", "ux", "test", "quality", "security", "performance", "maintainability", "best-practices"],
+      "description": "Discovery perspective"
+    },
+    "discovery_id": {
+      "type": "string",
+      "pattern": "^DSC-\\d{8}-\\d{6}$",
+      "description": "Parent discovery session ID"
+    },
+    "analysis_timestamp": {
+      "type": "string",
+      "format": "date-time",
+      "description": "ISO 8601 timestamp of analysis"
+    },
+    "cli_tool_used": {
+      "type": "string",
+      "enum": ["gemini", "qwen", "codex"],
+      "description": "CLI tool that performed the analysis"
+    },
+    "model": {
+      "type": "string",
+      "description": "Specific model version used",
+      "examples": ["gemini-2.5-pro", "qwen-max"]
+    },
+    "analysis_duration_ms": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Analysis duration in milliseconds"
+    },
+    "summary": {
+      "type": "object",
+      "required": ["total_findings"],
+      "properties": {
+        "total_findings": { "type": "integer", "minimum": 0 },
+        "critical": { "type": "integer", "minimum": 0 },
+        "high": { "type": "integer", "minimum": 0 },
+        "medium": { "type": "integer", "minimum": 0 },
+        "low": { "type": "integer", "minimum": 0 },
+        "files_analyzed": { "type": "integer", "minimum": 0 }
+      },
+      "description": "Summary statistics (FLAT structure, NOT nested)"
+    },
+    "findings": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "title", "perspective", "priority", "category", "description", "file", "line"],
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^dsc-[a-z]+-\\d{3}-[a-f0-9]{8}$",
+            "description": "Unique finding ID: dsc-{perspective}-{seq}-{uuid8}",
+            "examples": ["dsc-bug-001-a1b2c3d4"]
+          },
+          "title": {
+            "type": "string",
+            "minLength": 10,
+            "maxLength": 200,
+            "description": "Concise finding title"
+          },
+          "perspective": {
+            "type": "string",
+            "enum": ["bug", "ux", "test", "quality", "security", "performance", "maintainability", "best-practices"]
+          },
+          "priority": {
+            "type": "string",
+            "enum": ["critical", "high", "medium", "low"],
+            "description": "Priority level (lowercase only)"
+          },
+          "category": {
+            "type": "string",
+            "description": "Perspective-specific category",
+            "examples": ["null-check", "edge-case", "missing-test", "complexity", "injection"]
+          },
+          "description": {
+            "type": "string",
+            "minLength": 20,
+            "description": "Detailed description of the finding"
+          },
+          "file": {
+            "type": "string",
+            "description": "File path relative to project root"
+          },
+          "line": {
+            "type": "integer",
+            "minimum": 1,
+            "description": "Line number of the finding"
+          },
+          "snippet": {
+            "type": "string",
+            "description": "Relevant code snippet"
+          },
+          "suggested_issue": {
+            "type": "object",
+            "required": ["title", "type", "priority"],
+            "properties": {
+              "title": {
+                "type": "string",
+                "description": "Suggested issue title for export"
+              },
+              "type": {
+                "type": "string",
+                "enum": ["bug", "feature", "enhancement", "refactor", "test", "docs"],
+                "description": "Issue type"
+              },
+              "priority": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 5,
+                "description": "Priority 1-5 (1=critical, 5=low)"
+              },
+              "tags": {
+                "type": "array",
+                "items": { "type": "string" },
+                "description": "Suggested tags for the issue"
+              }
+            },
+            "description": "Pre-filled issue suggestion for export"
+          },
+          "external_reference": {
+            "type": ["object", "null"],
+            "properties": {
+              "source": { "type": "string" },
+              "url": { "type": "string", "format": "uri" },
+              "relevance": { "type": "string" }
+            },
+            "description": "External reference from Exa research (if applicable)"
+          },
+          "confidence": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 1,
+            "description": "Confidence score 0.0-1.0"
+          },
+          "impact": {
+            "type": "string",
+            "description": "Description of potential impact"
+          },
+          "recommendation": {
+            "type": "string",
+            "description": "Specific recommendation to address the finding"
+          },
+          "metadata": {
+            "type": "object",
+            "additionalProperties": true,
+            "description": "Additional metadata (CWE ID, OWASP category, etc.)"
+          }
+        }
+      },
+      "description": "Array of discovered findings"
+    },
+    "cross_references": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "finding_id": { "type": "string" },
+          "related_perspectives": {
+            "type": "array",
+            "items": { "type": "string" }
+          },
+          "reason": { "type": "string" }
+        }
+      },
+      "description": "Cross-references to findings in other perspectives"
+    }
+  },
+  "examples": [
+    {
+      "perspective": "bug",
+      "discovery_id": "DSC-20250128-143022",
+      "analysis_timestamp": "2025-01-28T14:35:00Z",
+      "cli_tool_used": "gemini",
+      "model": "gemini-2.5-pro",
+      "analysis_duration_ms": 45000,
+      "summary": {
+        "total_findings": 8,
+        "critical": 1,
+        "high": 2,
+        "medium": 3,
+        "low": 2,
+        "files_analyzed": 5
+      },
+      "findings": [
+        {
+          "id": "dsc-bug-001-a1b2c3d4",
+          "title": "Missing null check in user validation",
+          "perspective": "bug",
+          "priority": "high",
+          "category": "null-check",
+          "description": "User object is accessed without null check after database query, which may fail if user doesn't exist",
+          "file": "src/auth/validator.ts",
+          "line": 45,
+          "snippet": "const user = await db.findUser(id);\nreturn user.email;  // user may be null",
+          "suggested_issue": {
+            "title": "Add null check in user validation",
+            "type": "bug",
+            "priority": 2,
+            "tags": ["bug", "auth"]
+          },
+          "external_reference": null,
+          "confidence": 0.85,
+          "impact": "Runtime error when user not found",
+          "recommendation": "Add null check: if (!user) throw new NotFoundError('User not found');"
+        }
+      ],
+      "cross_references": []
+    }
+  ]
+}

.ccw/workflows/cli-templates/schemas/discovery-state-schema.json

@@ -0,0 +1,125 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "discovery-state-schema",
+  "title": "Discovery State Schema (Merged)",
+  "description": "Unified schema for issue discovery session (state + progress merged)",
+  "type": "object",
+  "required": ["discovery_id", "target_pattern", "phase", "created_at"],
+  "properties": {
+    "discovery_id": {
+      "type": "string",
+      "description": "Unique discovery session ID",
+      "pattern": "^DSC-\\d{8}-\\d{6}$",
+      "examples": ["DSC-20250128-143022"]
+    },
+    "target_pattern": {
+      "type": "string",
+      "description": "File/directory pattern being analyzed",
+      "examples": ["src/auth/**", "codex-lens/**/*.py"]
+    },
+    "phase": {
+      "type": "string",
+      "enum": ["initialization", "parallel", "aggregation", "complete"],
+      "description": "Current execution phase"
+    },
+    "created_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "updated_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "target": {
+      "type": "object",
+      "description": "Target module information",
+      "properties": {
+        "files_count": {
+          "type": "object",
+          "properties": {
+            "source": { "type": "integer" },
+            "tests": { "type": "integer" },
+            "total": { "type": "integer" }
+          }
+        },
+        "project": {
+          "type": "object",
+          "properties": {
+            "name": { "type": "string" },
+            "version": { "type": "string" }
+          }
+        }
+      }
+    },
+    "perspectives": {
+      "type": "array",
+      "description": "Perspective analysis status (merged from progress)",
+      "items": {
+        "type": "object",
+        "required": ["name", "status"],
+        "properties": {
+          "name": {
+            "type": "string",
+            "enum": ["bug", "ux", "test", "quality", "security", "performance", "maintainability", "best-practices"]
+          },
+          "status": {
+            "type": "string",
+            "enum": ["pending", "in_progress", "completed", "failed"]
+          },
+          "findings": {
+            "type": "integer",
+            "minimum": 0
+          }
+        }
+      }
+    },
+    "external_research": {
+      "type": "object",
+      "properties": {
+        "enabled": { "type": "boolean", "default": false },
+        "completed": { "type": "boolean", "default": false }
+      }
+    },
+    "results": {
+      "type": "object",
+      "description": "Aggregated results (final phase)",
+      "properties": {
+        "total_findings": { "type": "integer", "minimum": 0 },
+        "issues_generated": { "type": "integer", "minimum": 0 },
+        "priority_distribution": {
+          "type": "object",
+          "properties": {
+            "critical": { "type": "integer" },
+            "high": { "type": "integer" },
+            "medium": { "type": "integer" },
+            "low": { "type": "integer" }
+          }
+        }
+      }
+    }
+  },
+  "examples": [
+    {
+      "discovery_id": "DSC-20251228-182237",
+      "target_pattern": "codex-lens/**/*.py",
+      "phase": "complete",
+      "created_at": "2025-12-28T18:22:37+08:00",
+      "updated_at": "2025-12-28T18:35:00+08:00",
+      "target": {
+        "files_count": { "source": 48, "tests": 44, "total": 93 },
+        "project": { "name": "codex-lens", "version": "0.1.0" }
+      },
+      "perspectives": [
+        { "name": "bug", "status": "completed", "findings": 15 },
+        { "name": "test", "status": "completed", "findings": 11 },
+        { "name": "quality", "status": "completed", "findings": 12 }
+      ],
+      "external_research": { "enabled": false, "completed": false },
+      "results": {
+        "total_findings": 37,
+        "issues_generated": 15,
+        "priority_distribution": { "critical": 4, "high": 13, "medium": 16, "low": 6 }
+      }
+    }
+  ]
+}

.ccw/workflows/cli-templates/schemas/explore-json-schema.json

@@ -0,0 +1,124 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Exploration Context Schema",
+  "description": "Code exploration results from cli-explore-agent for task context gathering",
+  "type": "object",
+  "required": [
+    "project_structure",
+    "relevant_files",
+    "patterns",
+    "dependencies",
+    "integration_points",
+    "constraints",
+    "clarification_needs",
+    "_metadata"
+  ],
+  "properties": {
+    "project_structure": {
+      "type": "string",
+      "description": "Overall architecture description: module organization, layer structure, component relationships"
+    },
+    "relevant_files": {
+      "type": "array",
+      "items": {
+        "oneOf": [
+          {"type": "string"},
+          {
+            "type": "object",
+            "required": ["path", "relevance"],
+            "properties": {
+              "path": {"type": "string", "description": "File path relative to project root"},
+              "relevance": {"type": "number", "minimum": 0, "maximum": 1, "description": "Relevance score 0.0-1.0 (0.7+ high, 0.5-0.7 medium, <0.5 low)"},
+              "rationale": {"type": "string", "description": "Brief explanation of why this file is relevant from this exploration angle"}
+            }
+          }
+        ]
+      },
+      "description": "File paths to be modified or referenced for the task. Prefer object format with relevance scores for synthesis prioritization."
+    },
+    "patterns": {
+      "type": "string",
+      "description": "Existing code patterns, conventions, and styles found in the codebase"
+    },
+    "dependencies": {
+      "type": "string",
+      "description": "External and internal module dependencies relevant to the task"
+    },
+    "integration_points": {
+      "type": "string",
+      "description": "Where this task connects with existing code: APIs, hooks, events, shared state"
+    },
+    "constraints": {
+      "type": "string",
+      "description": "Technical constraints and limitations affecting implementation"
+    },
+    "clarification_needs": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["question", "context", "options"],
+        "properties": {
+          "question": {
+            "type": "string",
+            "description": "The clarification question to ask user"
+          },
+          "context": {
+            "type": "string",
+            "description": "Background context explaining why this clarification is needed"
+          },
+          "options": {
+            "type": "array",
+            "items": {"type": "string"},
+            "description": "Available options for user to choose from (2-4 options)"
+          },
+          "recommended": {
+            "type": "integer",
+            "minimum": 0,
+            "description": "Zero-based index of recommended option in the options array. Based on codebase patterns and best practices analysis."
+          }
+        }
+      },
+      "description": "Ambiguities requiring user input before planning"
+    },
+    "_metadata": {
+      "type": "object",
+      "required": ["timestamp", "task_description", "source"],
+      "properties": {
+        "timestamp": {
+          "type": "string",
+          "format": "date-time",
+          "description": "ISO 8601 timestamp of exploration"
+        },
+        "task_description": {
+          "type": "string",
+          "description": "Original task description that triggered exploration"
+        },
+        "source": {
+          "type": "string",
+          "const": "cli-explore-agent",
+          "description": "Agent that performed exploration"
+        },
+        "exploration_angle": {
+          "type": "string",
+          "description": "Agent-chosen exploration angle (e.g., 'architecture', 'security', 'dataflow')"
+        },
+        "exploration_index": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 4,
+          "description": "Exploration index (1-4) in parallel exploration set"
+        },
+        "total_explorations": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 4,
+          "description": "Total number of parallel explorations"
+        },
+        "duration_seconds": {
+          "type": "integer",
+          "description": "Exploration duration in seconds"
+        }
+      }
+    }
+  }
+}

.ccw/workflows/cli-templates/schemas/fix-plan-json-schema.json

@@ -0,0 +1,298 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Fix Plan Schema",
+  "description": "Bug fix plan from cli-lite-planning-agent or direct planning",
+  "type": "object",
+  "required": [
+    "summary",
+    "root_cause",
+    "strategy",
+    "tasks",
+    "estimated_time",
+    "recommended_execution",
+    "severity",
+    "risk_level",
+    "_metadata"
+  ],
+  "properties": {
+    "summary": {
+      "type": "string",
+      "description": "2-3 sentence overview of the fix plan"
+    },
+    "root_cause": {
+      "type": "string",
+      "description": "Consolidated root cause statement from all diagnoses"
+    },
+    "strategy": {
+      "type": "string",
+      "enum": ["immediate_patch", "comprehensive_fix", "refactor"],
+      "description": "Fix strategy: immediate_patch (minimal change), comprehensive_fix (proper solution), refactor (structural improvement)"
+    },
+    "tasks": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 5,
+      "items": {
+        "type": "object",
+        "required": ["id", "title", "scope", "action", "description", "implementation", "verification"],
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^FIX[0-9]+$",
+            "description": "Task identifier (FIX1, FIX2, FIX3...)"
+          },
+          "title": {
+            "type": "string",
+            "description": "Task title (action verb + target, e.g., 'Fix token validation edge case')"
+          },
+          "scope": {
+            "type": "string",
+            "description": "Task scope: module path (src/auth/), feature name, or single file. Prefer module level."
+          },
+          "file": {
+            "type": "string",
+            "description": "Primary file (deprecated, use scope + modification_points instead)"
+          },
+          "action": {
+            "type": "string",
+            "enum": ["Fix", "Update", "Refactor", "Add", "Delete", "Configure"],
+            "description": "Primary action type"
+          },
+          "description": {
+            "type": "string",
+            "description": "What to fix (1-2 sentences)"
+          },
+          "modification_points": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "required": ["file", "target", "change"],
+              "properties": {
+                "file": {
+                  "type": "string",
+                  "description": "File path within scope"
+                },
+                "target": {
+                  "type": "string",
+                  "description": "Function/class/line range (e.g., 'validateToken:45-60')"
+                },
+                "change": {
+                  "type": "string",
+                  "description": "Brief description of change"
+                }
+              }
+            },
+            "description": "All modification points for this fix task. Group related changes into one task."
+          },
+          "implementation": {
+            "type": "array",
+            "items": {"type": "string"},
+            "minItems": 2,
+            "maxItems": 5,
+            "description": "Step-by-step fix implementation guide"
+          },
+          "verification": {
+            "type": "array",
+            "items": {"type": "string"},
+            "minItems": 1,
+            "maxItems": 3,
+            "description": "Verification/test criteria to confirm fix works"
+          },
+          "reference": {
+            "type": "object",
+            "properties": {
+              "pattern": {
+                "type": "string",
+                "description": "Pattern name to follow"
+              },
+              "files": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Reference file paths to study"
+              },
+              "examples": {
+                "type": "string",
+                "description": "Specific guidance or example references"
+              }
+            },
+            "description": "Reference materials for fix implementation (optional)"
+          },
+          "depends_on": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^FIX[0-9]+$"
+            },
+            "description": "Task IDs this task depends on (e.g., ['FIX1'])"
+          },
+          "risk": {
+            "type": "string",
+            "enum": ["low", "medium", "high"],
+            "description": "Risk level of this specific fix task"
+          },
+          "cli_execution_id": {
+            "type": "string",
+            "pattern": "^[a-zA-Z0-9_-]+$",
+            "description": "Fixed CLI execution ID for this fix task (e.g., 'session-FIX1', 'bugfix-001-diagnosis')"
+          },
+          "cli_execution": {
+            "type": "object",
+            "properties": {
+              "strategy": {
+                "type": "string",
+                "enum": ["new", "resume", "fork", "merge_fork"],
+                "description": "CLI execution strategy: new (no deps), resume (1 dep, continue), fork (1 dep, branch), merge_fork (N deps, combine)"
+              },
+              "resume_from": {
+                "type": "string",
+                "description": "Parent task's cli_execution_id (for resume/fork strategies)"
+              },
+              "merge_from": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Multiple parents' cli_execution_ids (for merge_fork strategy)"
+              }
+            },
+            "description": "CLI execution strategy based on task dependencies"
+          }
+        }
+      },
+      "description": "Structured fix task breakdown (1-5 tasks)"
+    },
+    "flow_control": {
+      "type": "object",
+      "properties": {
+        "execution_order": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "phase": {
+                "type": "string",
+                "description": "Phase name (e.g., 'parallel-1', 'sequential-1')"
+              },
+              "tasks": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Task IDs in this phase"
+              },
+              "type": {
+                "type": "string",
+                "enum": ["parallel", "sequential"],
+                "description": "Execution type"
+              }
+            }
+          },
+          "description": "Ordered execution phases"
+        },
+        "exit_conditions": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "string",
+              "description": "Condition for successful fix completion"
+            },
+            "failure": {
+              "type": "string",
+              "description": "Condition that indicates fix failure"
+            }
+          },
+          "description": "Conditions for fix workflow termination"
+        }
+      },
+      "description": "Execution flow control (optional, auto-inferred from depends_on if not provided)"
+    },
+    "focus_paths": {
+      "type": "array",
+      "items": {"type": "string"},
+      "description": "Key file paths affected by this fix (aggregated from tasks)"
+    },
+    "test_strategy": {
+      "type": "object",
+      "properties": {
+        "scope": {
+          "type": "string",
+          "enum": ["unit", "integration", "e2e", "smoke", "full"],
+          "description": "Test scope to run after fix"
+        },
+        "specific_tests": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Specific test files or patterns to run"
+        },
+        "manual_verification": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Manual verification steps if automated tests not available"
+        }
+      },
+      "description": "Testing strategy for fix verification"
+    },
+    "rollback_plan": {
+      "type": "object",
+      "properties": {
+        "strategy": {
+          "type": "string",
+          "enum": ["git_revert", "feature_flag", "manual"],
+          "description": "Rollback strategy if fix fails"
+        },
+        "steps": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Rollback steps"
+        }
+      },
+      "description": "Rollback plan if fix causes issues (optional, recommended for high severity)"
+    },
+    "estimated_time": {
+      "type": "string",
+      "description": "Total estimated fix time (e.g., '30 minutes', '2 hours')"
+    },
+    "recommended_execution": {
+      "type": "string",
+      "enum": ["Agent", "Codex"],
+      "description": "Recommended execution method based on complexity"
+    },
+    "severity": {
+      "type": "string",
+      "enum": ["Low", "Medium", "High", "Critical"],
+      "description": "Bug severity level"
+    },
+    "risk_level": {
+      "type": "string",
+      "enum": ["low", "medium", "high"],
+      "description": "Risk level of implementing the fix"
+    },
+    "_metadata": {
+      "type": "object",
+      "required": ["timestamp", "source"],
+      "properties": {
+        "timestamp": {
+          "type": "string",
+          "format": "date-time",
+          "description": "ISO 8601 timestamp of planning"
+        },
+        "source": {
+          "type": "string",
+          "enum": ["cli-lite-planning-agent", "direct-planning"],
+          "description": "Planning source"
+        },
+        "planning_mode": {
+          "type": "string",
+          "enum": ["direct", "agent-based"],
+          "description": "Planning execution mode"
+        },
+        "diagnosis_angles": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Diagnosis angles used for context"
+        },
+        "duration_seconds": {
+          "type": "integer",
+          "description": "Planning duration in seconds"
+        }
+      }
+    }
+  }
+}

.ccw/workflows/cli-templates/schemas/issues-jsonl-schema.json

@@ -0,0 +1,170 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Issues JSONL Schema",
+  "description": "Schema for each line in issues.jsonl (flat storage)",
+  "type": "object",
+  "required": ["id", "title", "status", "created_at"],
+  "properties": {
+    "id": {
+      "type": "string",
+      "description": "Issue ID (GH-123, ISS-xxx, DSC-001)"
+    },
+    "title": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string",
+      "enum": ["registered", "planning", "planned", "queued", "executing", "completed", "failed", "paused"],
+      "default": "registered"
+    },
+    "priority": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 5,
+      "default": 3,
+      "description": "1=critical, 2=high, 3=medium, 4=low, 5=trivial"
+    },
+    "context": {
+      "type": "string",
+      "description": "Issue context/description (markdown)"
+    },
+    "source": {
+      "type": "string",
+      "enum": ["github", "text", "discovery"],
+      "description": "Source of the issue"
+    },
+    "source_url": {
+      "type": "string",
+      "description": "Original source URL (for GitHub issues)"
+    },
+    "tags": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Issue tags"
+    },
+    "extended_context": {
+      "type": "object",
+      "description": "Minimal extended context for planning hints",
+      "properties": {
+        "location": {
+          "type": "string",
+          "description": "file:line format (e.g., 'src/auth.ts:42')"
+        },
+        "suggested_fix": {
+          "type": "string",
+          "description": "Suggested remediation"
+        },
+        "notes": {
+          "type": "string",
+          "description": "Additional notes (user clarifications or discovery hints)"
+        }
+      }
+    },
+    "affected_components": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Files/modules affected"
+    },
+    "feedback": {
+      "type": "array",
+      "description": "Execution feedback history (failures, clarifications, rejections) for planning phase reference",
+      "items": {
+        "type": "object",
+        "required": ["type", "stage", "content", "created_at"],
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": ["failure", "clarification", "rejection"],
+            "description": "Type of feedback"
+          },
+          "stage": {
+            "type": "string",
+            "enum": ["new", "plan", "execute"],
+            "description": "Which stage the feedback occurred (new=creation, plan=planning, execute=execution)"
+          },
+          "content": {
+            "type": "string",
+            "description": "JSON string for failures (with solution_id, task_id, error_type, message, stack_trace) or plain text for clarifications/rejections"
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Timestamp when feedback was created"
+          }
+        }
+      }
+    },
+    "lifecycle_requirements": {
+      "type": "object",
+      "properties": {
+        "test_strategy": {
+          "type": "string",
+          "enum": ["unit", "integration", "e2e", "manual", "auto"]
+        },
+        "regression_scope": {
+          "type": "string",
+          "enum": ["affected", "related", "full"]
+        },
+        "acceptance_type": {
+          "type": "string",
+          "enum": ["automated", "manual", "both"]
+        },
+        "commit_strategy": {
+          "type": "string",
+          "enum": ["per-task", "squash", "atomic"]
+        }
+      }
+    },
+    "bound_solution_id": {
+      "type": "string",
+      "description": "ID of the bound solution (null if none bound)"
+    },
+    "solution_count": {
+      "type": "integer",
+      "default": 0,
+      "description": "Number of candidate solutions"
+    },
+    "created_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "updated_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "planned_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "completed_at": {
+      "type": "string",
+      "format": "date-time"
+    }
+  },
+  "examples": [
+    {
+      "id": "DSC-001",
+      "title": "Fix: SQLite connection pool memory leak",
+      "status": "registered",
+      "priority": 1,
+      "context": "Connection pool cleanup only happens when MAX_POOL_SIZE is reached...",
+      "source": "discovery",
+      "tags": ["bug", "resource-leak", "critical"],
+      "extended_context": {
+        "location": "storage/sqlite_store.py:59",
+        "suggested_fix": "Implement periodic cleanup or weak references",
+        "notes": null
+      },
+      "affected_components": ["storage/sqlite_store.py"],
+      "lifecycle_requirements": {
+        "test_strategy": "unit",
+        "regression_scope": "affected",
+        "acceptance_type": "automated",
+        "commit_strategy": "per-task"
+      },
+      "bound_solution_id": null,
+      "solution_count": 0,
+      "created_at": "2025-12-28T18:22:37Z"
+    }
+  ]
+}

.ccw/workflows/cli-templates/schemas/multi-cli-discussion-schema.json

@@ -0,0 +1,421 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Multi-CLI Discussion Artifact Schema",
+  "description": "Visualization-friendly output for multi-CLI collaborative discussion agent",
+  "type": "object",
+  "required": ["metadata", "discussionTopic", "relatedFiles", "planning", "decision", "decisionRecords"],
+  "properties": {
+    "metadata": {
+      "type": "object",
+      "required": ["artifactId", "roundId", "timestamp", "contributingAgents"],
+      "properties": {
+        "artifactId": {
+          "type": "string",
+          "description": "Unique ID for this artifact (e.g., 'MCP-auth-refactor-2026-01-13-round-1')"
+        },
+        "roundId": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Discussion round number"
+        },
+        "timestamp": {
+          "type": "string",
+          "format": "date-time",
+          "description": "ISO 8601 timestamp"
+        },
+        "contributingAgents": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/AgentIdentifier"
+          },
+          "description": "Agents that contributed to this artifact"
+        },
+        "durationSeconds": {
+          "type": "integer",
+          "description": "Total duration in seconds"
+        },
+        "exportFormats": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": ["markdown", "html"]
+          },
+          "description": "Supported export formats"
+        }
+      }
+    },
+    "discussionTopic": {
+      "type": "object",
+      "required": ["title", "description", "status"],
+      "properties": {
+        "title": {
+          "$ref": "#/definitions/I18nLabel"
+        },
+        "description": {
+          "$ref": "#/definitions/I18nLabel"
+        },
+        "scope": {
+          "type": "object",
+          "properties": {
+            "included": {
+              "type": "array",
+              "items": { "$ref": "#/definitions/I18nLabel" },
+              "description": "What's in scope"
+            },
+            "excluded": {
+              "type": "array",
+              "items": { "$ref": "#/definitions/I18nLabel" },
+              "description": "What's explicitly out of scope"
+            }
+          }
+        },
+        "keyQuestions": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/I18nLabel" },
+          "description": "Questions being explored"
+        },
+        "status": {
+          "type": "string",
+          "enum": ["exploring", "analyzing", "debating", "decided", "blocked"],
+          "description": "Discussion status"
+        },
+        "tags": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Tags for filtering (e.g., ['auth', 'security', 'api'])"
+        }
+      }
+    },
+    "relatedFiles": {
+      "type": "object",
+      "properties": {
+        "fileTree": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/FileNode" },
+          "description": "File tree structure"
+        },
+        "dependencyGraph": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/DependencyEdge" },
+          "description": "Dependency relationships"
+        },
+        "impactSummary": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/FileImpact" },
+          "description": "File impact summary"
+        }
+      }
+    },
+    "planning": {
+      "type": "object",
+      "properties": {
+        "functional": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/Requirement" },
+          "description": "Functional requirements"
+        },
+        "nonFunctional": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/Requirement" },
+          "description": "Non-functional requirements"
+        },
+        "acceptanceCriteria": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/AcceptanceCriterion" },
+          "description": "Acceptance criteria"
+        }
+      }
+    },
+    "decision": {
+      "type": "object",
+      "required": ["status", "confidenceScore"],
+      "properties": {
+        "status": {
+          "type": "string",
+          "enum": ["pending", "decided", "conflict"],
+          "description": "Decision status"
+        },
+        "summary": {
+          "$ref": "#/definitions/I18nLabel"
+        },
+        "selectedSolution": {
+          "$ref": "#/definitions/Solution"
+        },
+        "rejectedAlternatives": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/RejectedSolution" }
+        },
+        "confidenceScore": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1,
+          "description": "Confidence score (0.0 to 1.0)"
+        }
+      }
+    },
+    "decisionRecords": {
+      "type": "object",
+      "properties": {
+        "timeline": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/DecisionEvent" },
+          "description": "Timeline of decision events"
+        }
+      }
+    },
+    "_internal": {
+      "type": "object",
+      "description": "Internal analysis data (for debugging)",
+      "properties": {
+        "cli_analyses": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/CLIAnalysis" }
+        },
+        "cross_verification": {
+          "$ref": "#/definitions/CrossVerification"
+        },
+        "convergence": {
+          "$ref": "#/definitions/ConvergenceMetrics"
+        }
+      }
+    }
+  },
+  "definitions": {
+    "I18nLabel": {
+      "type": "object",
+      "required": ["en", "zh"],
+      "properties": {
+        "en": { "type": "string" },
+        "zh": { "type": "string" }
+      },
+      "description": "Multi-language label for UI display"
+    },
+    "AgentIdentifier": {
+      "type": "object",
+      "required": ["name", "id"],
+      "properties": {
+        "name": {
+          "type": "string",
+          "enum": ["Gemini", "Codex", "Qwen", "Human", "System"]
+        },
+        "id": { "type": "string" }
+      }
+    },
+    "FileNode": {
+      "type": "object",
+      "required": ["path", "type"],
+      "properties": {
+        "path": { "type": "string" },
+        "type": {
+          "type": "string",
+          "enum": ["file", "directory"]
+        },
+        "modificationStatus": {
+          "type": "string",
+          "enum": ["added", "modified", "deleted", "unchanged"]
+        },
+        "impactScore": {
+          "type": "string",
+          "enum": ["critical", "high", "medium", "low"]
+        },
+        "children": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/FileNode" }
+        },
+        "codeSnippet": { "$ref": "#/definitions/CodeSnippet" }
+      }
+    },
+    "DependencyEdge": {
+      "type": "object",
+      "required": ["source", "target", "relationship"],
+      "properties": {
+        "source": { "type": "string" },
+        "target": { "type": "string" },
+        "relationship": { "type": "string" }
+      }
+    },
+    "FileImpact": {
+      "type": "object",
+      "required": ["filePath", "score", "reasoning"],
+      "properties": {
+        "filePath": { "type": "string" },
+        "line": { "type": "integer" },
+        "score": {
+          "type": "string",
+          "enum": ["critical", "high", "medium", "low"]
+        },
+        "reasoning": { "$ref": "#/definitions/I18nLabel" }
+      }
+    },
+    "CodeSnippet": {
+      "type": "object",
+      "required": ["startLine", "endLine", "code"],
+      "properties": {
+        "startLine": { "type": "integer" },
+        "endLine": { "type": "integer" },
+        "code": { "type": "string" },
+        "language": { "type": "string" },
+        "comment": { "$ref": "#/definitions/I18nLabel" }
+      }
+    },
+    "Requirement": {
+      "type": "object",
+      "required": ["id", "description", "priority"],
+      "properties": {
+        "id": { "type": "string" },
+        "description": { "$ref": "#/definitions/I18nLabel" },
+        "priority": {
+          "type": "string",
+          "enum": ["critical", "high", "medium", "low"]
+        },
+        "source": { "type": "string" }
+      }
+    },
+    "AcceptanceCriterion": {
+      "type": "object",
+      "required": ["id", "description", "isMet"],
+      "properties": {
+        "id": { "type": "string" },
+        "description": { "$ref": "#/definitions/I18nLabel" },
+        "isMet": { "type": "boolean" }
+      }
+    },
+    "Solution": {
+      "type": "object",
+      "required": ["id", "title", "description"],
+      "properties": {
+        "id": { "type": "string" },
+        "title": { "$ref": "#/definitions/I18nLabel" },
+        "description": { "$ref": "#/definitions/I18nLabel" },
+        "pros": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/I18nLabel" }
+        },
+        "cons": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/I18nLabel" }
+        },
+        "estimatedEffort": { "$ref": "#/definitions/I18nLabel" },
+        "risk": {
+          "type": "string",
+          "enum": ["critical", "high", "medium", "low"]
+        },
+        "affectedFiles": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/FileImpact" }
+        },
+        "sourceCLIs": {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      }
+    },
+    "RejectedSolution": {
+      "allOf": [
+        { "$ref": "#/definitions/Solution" },
+        {
+          "type": "object",
+          "required": ["rejectionReason"],
+          "properties": {
+            "rejectionReason": { "$ref": "#/definitions/I18nLabel" }
+          }
+        }
+      ]
+    },
+    "DecisionEvent": {
+      "type": "object",
+      "required": ["eventId", "timestamp", "type", "contributor", "summary"],
+      "properties": {
+        "eventId": { "type": "string" },
+        "timestamp": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "type": {
+          "type": "string",
+          "enum": ["proposal", "argument", "agreement", "disagreement", "decision", "reversal"]
+        },
+        "contributor": { "$ref": "#/definitions/AgentIdentifier" },
+        "summary": { "$ref": "#/definitions/I18nLabel" },
+        "evidence": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/Evidence" }
+        },
+        "reversibility": {
+          "type": "string",
+          "enum": ["easily_reversible", "requires_refactoring", "irreversible"]
+        }
+      }
+    },
+    "Evidence": {
+      "type": "object",
+      "required": ["type", "content", "description"],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["link", "code_snippet", "log_output", "benchmark", "reference"]
+        },
+        "content": {},
+        "description": { "$ref": "#/definitions/I18nLabel" }
+      }
+    },
+    "CLIAnalysis": {
+      "type": "object",
+      "required": ["tool", "perspective", "feasibility_score"],
+      "properties": {
+        "tool": {
+          "type": "string",
+          "enum": ["gemini", "codex", "qwen"]
+        },
+        "perspective": { "type": "string" },
+        "feasibility_score": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        },
+        "findings": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "implementation_approaches": { "type": "array" },
+        "technical_concerns": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "code_locations": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/FileImpact" }
+        }
+      }
+    },
+    "CrossVerification": {
+      "type": "object",
+      "properties": {
+        "agreements": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "disagreements": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "resolution": { "type": "string" }
+      }
+    },
+    "ConvergenceMetrics": {
+      "type": "object",
+      "properties": {
+        "score": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        },
+        "new_insights": { "type": "boolean" },
+        "recommendation": {
+          "type": "string",
+          "enum": ["continue", "converged", "user_input_needed"]
+        }
+      }
+    }
+  }
+}

.ccw/workflows/cli-templates/schemas/plan-json-schema.json

@@ -0,0 +1,444 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Plan Object Schema",
+  "description": "Implementation plan from cli-lite-planning-agent or direct planning",
+  "type": "object",
+  "required": [
+    "summary",
+    "approach",
+    "tasks",
+    "estimated_time",
+    "recommended_execution",
+    "complexity",
+    "_metadata"
+  ],
+  "properties": {
+    "summary": {
+      "type": "string",
+      "description": "2-3 sentence overview of the implementation plan"
+    },
+    "approach": {
+      "type": "string",
+      "description": "High-level implementation strategy and methodology"
+    },
+    "tasks": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "required": ["id", "title", "scope", "action", "description", "implementation", "acceptance"],
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^T[0-9]+$",
+            "description": "Task identifier (T1, T2, T3...)"
+          },
+          "title": {
+            "type": "string",
+            "description": "Task title (action verb + target module/feature)"
+          },
+          "scope": {
+            "type": "string",
+            "description": "Task scope: module path (src/auth/), feature name, or single file. Prefer module/feature level over single file."
+          },
+          "file": {
+            "type": "string",
+            "description": "Primary file (deprecated, use scope + modification_points instead)"
+          },
+          "action": {
+            "type": "string",
+            "enum": ["Create", "Update", "Implement", "Refactor", "Add", "Delete", "Configure", "Test", "Fix"],
+            "description": "Primary action type"
+          },
+          "description": {
+            "type": "string",
+            "description": "What to implement (1-2 sentences)"
+          },
+          "modification_points": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "required": ["file", "target", "change"],
+              "properties": {
+                "file": {
+                  "type": "string",
+                  "description": "File path within scope"
+                },
+                "target": {
+                  "type": "string",
+                  "description": "Function/class/line range (e.g., 'validateToken:45-60')"
+                },
+                "change": {
+                  "type": "string",
+                  "description": "Brief description of change"
+                }
+              }
+            },
+            "description": "All modification points for this task. Group related changes (same feature/module) into one task with multiple modification_points."
+          },
+          "implementation": {
+            "type": "array",
+            "items": {"type": "string"},
+            "minItems": 2,
+            "maxItems": 7,
+            "description": "Step-by-step implementation guide"
+          },
+          "reference": {
+            "type": "object",
+            "properties": {
+              "pattern": {
+                "type": "string",
+                "description": "Pattern name to follow"
+              },
+              "files": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Reference file paths to study"
+              },
+              "examples": {
+                "type": "string",
+                "description": "Specific guidance or example references"
+              }
+            },
+            "description": "Reference materials for implementation (optional)"
+          },
+          "acceptance": {
+            "type": "array",
+            "items": {"type": "string"},
+            "minItems": 1,
+            "maxItems": 4,
+            "description": "Verification criteria (quantified, testable)"
+          },
+          "depends_on": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^T[0-9]+$"
+            },
+            "description": "Task IDs this task depends on (e.g., ['T1', 'T2'])"
+          },
+          "cli_execution_id": {
+            "type": "string",
+            "pattern": "^[a-zA-Z0-9_-]+$",
+            "description": "Fixed CLI execution ID for this task (e.g., 'session-T1', 'IMPL-001-analysis')"
+          },
+          "cli_execution": {
+            "type": "object",
+            "properties": {
+              "strategy": {
+                "type": "string",
+                "enum": ["new", "resume", "fork", "merge_fork"],
+                "description": "CLI execution strategy: new (no deps), resume (1 dep, continue), fork (1 dep, branch), merge_fork (N deps, combine)"
+              },
+              "resume_from": {
+                "type": "string",
+                "description": "Parent task's cli_execution_id (for resume/fork strategies)"
+              },
+              "merge_from": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Multiple parents' cli_execution_ids (for merge_fork strategy)"
+              }
+            },
+            "description": "CLI execution strategy based on task dependencies"
+          },
+          "rationale": {
+            "type": "object",
+            "properties": {
+              "chosen_approach": {
+                "type": "string",
+                "description": "The selected implementation approach and why it was chosen"
+              },
+              "alternatives_considered": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Alternative approaches that were considered but not chosen"
+              },
+              "decision_factors": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Key factors that influenced the decision (performance, maintainability, cost, etc.)"
+              },
+              "tradeoffs": {
+                "type": "string",
+                "description": "Known tradeoffs of the chosen approach"
+              }
+            },
+            "description": "Design rationale explaining WHY this approach was chosen (required for Medium/High complexity)"
+          },
+          "verification": {
+            "type": "object",
+            "properties": {
+              "unit_tests": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "List of unit test names/descriptions to create"
+              },
+              "integration_tests": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "List of integration test names/descriptions to create"
+              },
+              "manual_checks": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Manual verification steps with specific actions"
+              },
+              "success_metrics": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Quantified metrics for success (e.g., 'Response time <200ms', 'Coverage >80%')"
+              }
+            },
+            "description": "Detailed verification steps beyond acceptance criteria (required for Medium/High complexity)"
+          },
+          "risks": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": ["description", "probability", "impact", "mitigation"],
+              "properties": {
+                "description": {
+                  "type": "string",
+                  "description": "Description of the risk"
+                },
+                "probability": {
+                  "type": "string",
+                  "enum": ["Low", "Medium", "High"],
+                  "description": "Likelihood of the risk occurring"
+                },
+                "impact": {
+                  "type": "string",
+                  "enum": ["Low", "Medium", "High"],
+                  "description": "Impact severity if the risk occurs"
+                },
+                "mitigation": {
+                  "type": "string",
+                  "description": "Strategy to mitigate or prevent the risk"
+                },
+                "fallback": {
+                  "type": "string",
+                  "description": "Alternative approach if mitigation fails"
+                }
+              }
+            },
+            "description": "Risk assessment and mitigation strategies (required for High complexity)"
+          },
+          "code_skeleton": {
+            "type": "object",
+            "properties": {
+              "interfaces": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "name": {"type": "string"},
+                    "definition": {"type": "string"},
+                    "purpose": {"type": "string"}
+                  }
+                },
+                "description": "Key interface/type definitions"
+              },
+              "key_functions": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "signature": {"type": "string"},
+                    "purpose": {"type": "string"},
+                    "returns": {"type": "string"}
+                  }
+                },
+                "description": "Critical function signatures"
+              },
+              "classes": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "name": {"type": "string"},
+                    "purpose": {"type": "string"},
+                    "methods": {
+                      "type": "array",
+                      "items": {"type": "string"}
+                    }
+                  }
+                },
+                "description": "Key class structures"
+              }
+            },
+            "description": "Code skeleton with interface/function signatures (required for High complexity)"
+          }
+        }
+      },
+      "description": "Structured task breakdown (1-10 tasks)"
+    },
+    "data_flow": {
+      "type": "object",
+      "properties": {
+        "diagram": {
+          "type": "string",
+          "description": "ASCII/text representation of data flow (e.g., 'A → B → C')"
+        },
+        "stages": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["stage", "input", "output", "component"],
+            "properties": {
+              "stage": {
+                "type": "string",
+                "description": "Stage name (e.g., 'Extraction', 'Processing', 'Storage')"
+              },
+              "input": {
+                "type": "string",
+                "description": "Input data format/type"
+              },
+              "output": {
+                "type": "string",
+                "description": "Output data format/type"
+              },
+              "component": {
+                "type": "string",
+                "description": "Component/module handling this stage"
+              },
+              "transformations": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Data transformations applied in this stage"
+              }
+            }
+          },
+          "description": "Detailed data flow stages"
+        },
+        "dependencies": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "External dependencies or data sources"
+        }
+      },
+      "description": "Global data flow design showing how data moves through the system (required for High complexity)"
+    },
+    "design_decisions": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["decision", "rationale"],
+        "properties": {
+          "decision": {
+            "type": "string",
+            "description": "The design decision made"
+          },
+          "rationale": {
+            "type": "string",
+            "description": "Why this decision was made"
+          },
+          "tradeoff": {
+            "type": "string",
+            "description": "What was traded off for this decision"
+          },
+          "alternatives": {
+            "type": "array",
+            "items": {"type": "string"},
+            "description": "Alternatives that were considered"
+          }
+        }
+      },
+      "description": "Global design decisions that affect the entire plan"
+    },
+    "flow_control": {
+      "type": "object",
+      "properties": {
+        "execution_order": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "phase": {
+                "type": "string",
+                "description": "Phase name (e.g., 'parallel-1', 'sequential-1')"
+              },
+              "tasks": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Task IDs in this phase"
+              },
+              "type": {
+                "type": "string",
+                "enum": ["parallel", "sequential"],
+                "description": "Execution type"
+              }
+            }
+          },
+          "description": "Ordered execution phases"
+        },
+        "exit_conditions": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "string",
+              "description": "Condition for successful completion"
+            },
+            "failure": {
+              "type": "string",
+              "description": "Condition that indicates failure"
+            }
+          },
+          "description": "Conditions for workflow termination"
+        }
+      },
+      "description": "Execution flow control (optional, auto-inferred from depends_on if not provided)"
+    },
+    "focus_paths": {
+      "type": "array",
+      "items": {"type": "string"},
+      "description": "Key file paths affected by this plan (aggregated from tasks)"
+    },
+    "estimated_time": {
+      "type": "string",
+      "description": "Total estimated implementation time (e.g., '30 minutes', '2 hours')"
+    },
+    "recommended_execution": {
+      "type": "string",
+      "enum": ["Agent", "Codex"],
+      "description": "Recommended execution method based on complexity"
+    },
+    "complexity": {
+      "type": "string",
+      "enum": ["Low", "Medium", "High"],
+      "description": "Task complexity level"
+    },
+    "_metadata": {
+      "type": "object",
+      "required": ["timestamp", "source"],
+      "properties": {
+        "timestamp": {
+          "type": "string",
+          "format": "date-time",
+          "description": "ISO 8601 timestamp of planning"
+        },
+        "source": {
+          "type": "string",
+          "enum": ["cli-lite-planning-agent", "direct-planning"],
+          "description": "Planning source"
+        },
+        "planning_mode": {
+          "type": "string",
+          "enum": ["direct", "agent-based"],
+          "description": "Planning execution mode"
+        },
+        "exploration_angles": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Exploration angles used for context"
+        },
+        "duration_seconds": {
+          "type": "integer",
+          "description": "Planning duration in seconds"
+        }
+      }
+    }
+  }
+}

.ccw/workflows/cli-templates/schemas/plan-verify-agent-schema.json

@@ -0,0 +1,51 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Plan Verification Agent Schema",
+  "description": "Defines dimensions, severity rules, and CLI templates for plan verification agent",
+
+  "dimensions": {
+    "A": { "name": "User Intent Alignment", "tier": 1, "severity": "CRITICAL",
+           "checks": ["Goal Alignment", "Scope Drift", "Success Criteria Match", "Intent Conflicts"] },
+    "B": { "name": "Requirements Coverage", "tier": 1, "severity": "CRITICAL",
+           "checks": ["Orphaned Requirements", "Unmapped Tasks", "NFR Coverage Gaps"] },
+    "C": { "name": "Consistency Validation", "tier": 1, "severity": "CRITICAL",
+           "checks": ["Requirement Conflicts", "Architecture Drift", "Terminology Drift", "Data Model Inconsistency"] },
+    "D": { "name": "Dependency Integrity", "tier": 2, "severity": "HIGH",
+           "checks": ["Circular Dependencies", "Missing Dependencies", "Broken Dependencies", "Logical Ordering"] },
+    "E": { "name": "Synthesis Alignment", "tier": 2, "severity": "HIGH",
+           "checks": ["Priority Conflicts", "Success Criteria Mismatch", "Risk Mitigation Gaps"] },
+    "F": { "name": "Task Specification Quality", "tier": 3, "severity": "MEDIUM",
+           "checks": ["Ambiguous Focus Paths", "Underspecified Acceptance", "Missing Artifacts", "Weak Flow Control"] },
+    "G": { "name": "Duplication Detection", "tier": 4, "severity": "LOW",
+           "checks": ["Overlapping Task Scope", "Redundant Coverage"] },
+    "H": { "name": "Feasibility Assessment", "tier": 4, "severity": "LOW",
+           "checks": ["Complexity Misalignment", "Resource Conflicts", "Skill Gap Risks"] },
+    "I": { "name": "Constraints Compliance", "tier": 1, "severity": "CRITICAL",
+           "checks": ["Consolidated Constraints Violation", "Phase Constraint Ignored", "User Constraint Override"] },
+    "J": { "name": "N+1 Context Validation", "tier": 2, "severity": "HIGH",
+           "checks": ["Deferred Item Included", "Decision Contradiction", "Revisit Flag Ignored"] }
+  },
+
+  "tiers": {
+    "1": { "dimensions": ["A", "B", "C", "I"], "priority": "CRITICAL", "limit": null, "rule": "analysis-review-architecture" },
+    "2": { "dimensions": ["D", "E", "J"], "priority": "HIGH", "limit": 15, "rule": "analysis-diagnose-bug-root-cause" },
+    "3": { "dimensions": ["F"], "priority": "MEDIUM", "limit": 20, "rule": "analysis-analyze-code-patterns" },
+    "4": { "dimensions": ["G", "H"], "priority": "LOW", "limit": 15, "rule": "analysis-analyze-code-patterns" }
+  },
+
+  "severity_rules": {
+    "CRITICAL": ["User intent violation", "Synthesis authority violation", "Zero coverage", "Circular/broken deps", "Constraint violation"],
+    "HIGH": ["NFR gaps", "Priority conflicts", "Missing risk mitigation", "Deferred item included", "Decision contradiction"],
+    "MEDIUM": ["Terminology drift", "Missing refs", "Weak flow control"],
+    "LOW": ["Style improvements", "Minor redundancy"]
+  },
+
+  "quality_gate": {
+    "BLOCK_EXECUTION": { "condition": "critical > 0", "emoji": "🛑" },
+    "PROCEED_WITH_FIXES": { "condition": "critical == 0 && high > 0", "emoji": "⚠️" },
+    "PROCEED_WITH_CAUTION": { "condition": "critical == 0 && high == 0 && medium > 0", "emoji": "✅" },
+    "PROCEED": { "condition": "only low or none", "emoji": "✅" }
+  },
+
+  "token_budget": { "total_findings": 50, "early_exit": "CRITICAL > 0 in Tier 1 → skip Tier 3-4" }
+}

.ccw/workflows/cli-templates/schemas/project-guidelines-schema.json

@@ -0,0 +1,141 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Project Guidelines Schema",
+  "description": "Schema for project-guidelines.json - user-maintained rules and constraints",
+  "type": "object",
+  "required": ["conventions", "constraints", "_metadata"],
+  "properties": {
+    "conventions": {
+      "type": "object",
+      "description": "Coding conventions and standards",
+      "required": ["coding_style", "naming_patterns", "file_structure", "documentation"],
+      "properties": {
+        "coding_style": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Coding style rules (e.g., 'Use strict TypeScript mode', 'Prefer const over let')"
+        },
+        "naming_patterns": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Naming conventions (e.g., 'Use camelCase for variables', 'Use PascalCase for components')"
+        },
+        "file_structure": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "File organization rules (e.g., 'One component per file', 'Tests alongside source files')"
+        },
+        "documentation": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Documentation requirements (e.g., 'JSDoc for public APIs', 'README for each module')"
+        }
+      }
+    },
+    "constraints": {
+      "type": "object",
+      "description": "Technical constraints and boundaries",
+      "required": ["architecture", "tech_stack", "performance", "security"],
+      "properties": {
+        "architecture": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Architecture constraints (e.g., 'No circular dependencies', 'Services must be stateless')"
+        },
+        "tech_stack": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Technology constraints (e.g., 'No new dependencies without review', 'Use native fetch over axios')"
+        },
+        "performance": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Performance requirements (e.g., 'API response < 200ms', 'Bundle size < 500KB')"
+        },
+        "security": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Security requirements (e.g., 'Sanitize all user input', 'No secrets in code')"
+        }
+      }
+    },
+    "quality_rules": {
+      "type": "array",
+      "description": "Enforceable quality rules",
+      "items": {
+        "type": "object",
+        "required": ["rule", "scope"],
+        "properties": {
+          "rule": {
+            "type": "string",
+            "description": "The quality rule statement"
+          },
+          "scope": {
+            "type": "string",
+            "description": "Where the rule applies (e.g., 'all', 'src/**', 'tests/**')"
+          },
+          "enforced_by": {
+            "type": "string",
+            "description": "How the rule is enforced (e.g., 'eslint', 'pre-commit', 'code-review')"
+          }
+        }
+      }
+    },
+    "learnings": {
+      "type": "array",
+      "description": "Project learnings captured from workflow sessions",
+      "items": {
+        "type": "object",
+        "required": ["date", "insight"],
+        "properties": {
+          "date": {
+            "type": "string",
+            "format": "date",
+            "description": "Date the learning was captured (YYYY-MM-DD)"
+          },
+          "session_id": {
+            "type": "string",
+            "description": "WFS session ID where the learning originated"
+          },
+          "insight": {
+            "type": "string",
+            "description": "The learning or insight captured"
+          },
+          "context": {
+            "type": "string",
+            "description": "Additional context about when/why this learning applies"
+          },
+          "category": {
+            "type": "string",
+            "enum": ["architecture", "performance", "security", "testing", "workflow", "other"],
+            "description": "Category of the learning"
+          }
+        }
+      }
+    },
+    "_metadata": {
+      "type": "object",
+      "required": ["created_at", "version"],
+      "properties": {
+        "created_at": {
+          "type": "string",
+          "format": "date-time",
+          "description": "ISO 8601 timestamp of creation"
+        },
+        "version": {
+          "type": "string",
+          "description": "Schema version (e.g., '1.0.0')"
+        },
+        "last_updated": {
+          "type": "string",
+          "format": "date-time",
+          "description": "ISO 8601 timestamp of last update"
+        },
+        "updated_by": {
+          "type": "string",
+          "description": "Who/what last updated the file (e.g., 'user', 'workflow:session:solidify')"
+        }
+      }
+    }
+  }
+}

.ccw/workflows/cli-templates/schemas/project-tech-schema.json

@@ -0,0 +1,221 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Project Tech Schema",
+  "description": "Schema for project-tech.json - auto-generated technical analysis (stack, architecture, components)",
+  "type": "object",
+  "required": [
+    "project_name",
+    "initialized_at",
+    "overview",
+    "features",
+    "statistics",
+    "_metadata"
+  ],
+  "properties": {
+    "project_name": {
+      "type": "string",
+      "description": "Project name extracted from git repo or directory"
+    },
+    "initialized_at": {
+      "type": "string",
+      "format": "date-time",
+      "description": "ISO 8601 timestamp of initialization"
+    },
+    "overview": {
+      "type": "object",
+      "required": [
+        "description",
+        "technology_stack",
+        "architecture",
+        "key_components"
+      ],
+      "properties": {
+        "description": {
+          "type": "string",
+          "description": "Brief project description (e.g., 'TypeScript web application with React frontend')"
+        },
+        "technology_stack": {
+          "type": "object",
+          "required": ["languages", "frameworks", "build_tools", "test_frameworks"],
+          "properties": {
+            "languages": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "required": ["name", "file_count", "primary"],
+                "properties": {
+                  "name": {
+                    "type": "string",
+                    "description": "Language name (e.g., TypeScript, Python)"
+                  },
+                  "file_count": {
+                    "type": "integer",
+                    "description": "Number of source files in this language"
+                  },
+                  "primary": {
+                    "type": "boolean",
+                    "description": "True if this is the primary language"
+                  }
+                }
+              }
+            },
+            "frameworks": {
+              "type": "array",
+              "items": {"type": "string"},
+              "description": "Detected frameworks (React, Express, Django, etc.)"
+            },
+            "build_tools": {
+              "type": "array",
+              "items": {"type": "string"},
+              "description": "Build tools and package managers (npm, cargo, maven, etc.)"
+            },
+            "test_frameworks": {
+              "type": "array",
+              "items": {"type": "string"},
+              "description": "Testing frameworks (jest, pytest, go test, etc.)"
+            }
+          }
+        },
+        "architecture": {
+          "type": "object",
+          "required": ["style", "layers", "patterns"],
+          "properties": {
+            "style": {
+              "type": "string",
+              "description": "Architecture style (MVC, microservices, layered, etc.)"
+            },
+            "layers": {
+              "type": "array",
+              "items": {"type": "string"},
+              "description": "Architectural layers (presentation, business-logic, data-access)"
+            },
+            "patterns": {
+              "type": "array",
+              "items": {"type": "string"},
+              "description": "Design patterns (Repository, Factory, Singleton, etc.)"
+            }
+          }
+        },
+        "key_components": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": ["name", "path", "description", "importance"],
+            "properties": {
+              "name": {
+                "type": "string",
+                "description": "Component name"
+              },
+              "path": {
+                "type": "string",
+                "description": "Relative path to component directory"
+              },
+              "description": {
+                "type": "string",
+                "description": "Brief description of component functionality"
+              },
+              "importance": {
+                "type": "string",
+                "enum": ["high", "medium", "low"],
+                "description": "Component importance level"
+              }
+            }
+          },
+          "description": "5-10 core modules/components"
+        }
+      }
+    },
+    "features": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["session_id", "title", "completed_at", "tags"],
+        "properties": {
+          "session_id": {
+            "type": "string",
+            "description": "WFS session identifier"
+          },
+          "title": {
+            "type": "string",
+            "description": "Feature title/description"
+          },
+          "completed_at": {
+            "type": "string",
+            "format": "date-time",
+            "description": "ISO 8601 timestamp of completion"
+          },
+          "tags": {
+            "type": "array",
+            "items": {"type": "string"},
+            "description": "Feature tags for categorization"
+          }
+        }
+      },
+      "description": "Completed workflow features (populated by /workflow:session:complete)"
+    },
+    "development_index": {
+      "type": "object",
+      "description": "Categorized development history (lite-plan/lite-execute)",
+      "properties": {
+        "feature": { "type": "array", "items": { "$ref": "#/$defs/devIndexEntry" } },
+        "enhancement": { "type": "array", "items": { "$ref": "#/$defs/devIndexEntry" } },
+        "bugfix": { "type": "array", "items": { "$ref": "#/$defs/devIndexEntry" } },
+        "refactor": { "type": "array", "items": { "$ref": "#/$defs/devIndexEntry" } },
+        "docs": { "type": "array", "items": { "$ref": "#/$defs/devIndexEntry" } }
+      }
+    },
+    "statistics": {
+      "type": "object",
+      "required": ["total_features", "total_sessions", "last_updated"],
+      "properties": {
+        "total_features": {
+          "type": "integer",
+          "description": "Count of completed features"
+        },
+        "total_sessions": {
+          "type": "integer",
+          "description": "Count of workflow sessions"
+        },
+        "last_updated": {
+          "type": "string",
+          "format": "date-time",
+          "description": "ISO 8601 timestamp of last update"
+        }
+      }
+    },
+    "_metadata": {
+      "type": "object",
+      "required": ["initialized_by", "analysis_timestamp", "analysis_mode"],
+      "properties": {
+        "initialized_by": {
+          "type": "string",
+          "description": "Agent or tool that performed initialization"
+        },
+        "analysis_timestamp": {
+          "type": "string",
+          "format": "date-time",
+          "description": "ISO 8601 timestamp of analysis"
+        },
+        "analysis_mode": {
+          "type": "string",
+          "enum": ["deep-scan", "quick-scan", "bash-fallback"],
+          "description": "Analysis mode used"
+        }
+      }
+    }
+  },
+  "$defs": {
+    "devIndexEntry": {
+      "type": "object",
+      "required": ["title", "sub_feature", "date", "description", "status"],
+      "properties": {
+        "title": { "type": "string", "maxLength": 60 },
+        "sub_feature": { "type": "string", "description": "Module/component area" },
+        "date": { "type": "string", "format": "date" },
+        "description": { "type": "string", "maxLength": 100 },
+        "status": { "type": "string", "enum": ["completed", "partial"] },
+        "session_id": { "type": "string", "description": "lite-plan session ID" }
+      }
+    }
+  }
+}

.ccw/workflows/cli-templates/schemas/queue-schema.json

@@ -0,0 +1,248 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Issue Execution Queue Schema",
+  "description": "Execution queue supporting both task-level (T-N) and solution-level (S-N) granularity",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^QUE-[0-9]{8}-[0-9]{6}$",
+      "description": "Queue ID in format QUE-YYYYMMDD-HHMMSS"
+    },
+    "status": {
+      "type": "string",
+      "enum": ["active", "paused", "completed", "archived"],
+      "default": "active"
+    },
+    "issue_ids": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Issues included in this queue"
+    },
+    "solutions": {
+      "type": "array",
+      "description": "Solution-level queue items (preferred for new queues)",
+      "items": {
+        "$ref": "#/definitions/solutionItem"
+      }
+    },
+    "tasks": {
+      "type": "array",
+      "description": "Task-level queue items (legacy format)",
+      "items": {
+        "$ref": "#/definitions/taskItem"
+      }
+    },
+    "conflicts": {
+      "type": "array",
+      "description": "Detected conflicts between items",
+      "items": {
+        "$ref": "#/definitions/conflict"
+      }
+    },
+    "execution_groups": {
+      "type": "array",
+      "description": "Parallel/Sequential execution groups",
+      "items": {
+        "$ref": "#/definitions/executionGroup"
+      }
+    },
+    "_metadata": {
+      "type": "object",
+      "properties": {
+        "version": { "type": "string", "default": "2.0" },
+        "queue_type": {
+          "type": "string",
+          "enum": ["solution", "task"],
+          "description": "Queue granularity level"
+        },
+        "total_solutions": { "type": "integer" },
+        "total_tasks": { "type": "integer" },
+        "pending_count": { "type": "integer" },
+        "ready_count": { "type": "integer" },
+        "executing_count": { "type": "integer" },
+        "completed_count": { "type": "integer" },
+        "failed_count": { "type": "integer" },
+        "last_queue_formation": { "type": "string", "format": "date-time" },
+        "last_updated": { "type": "string", "format": "date-time" }
+      }
+    }
+  },
+  "definitions": {
+    "solutionItem": {
+      "type": "object",
+      "required": ["item_id", "issue_id", "solution_id", "status", "task_count", "files_touched"],
+      "properties": {
+        "item_id": {
+          "type": "string",
+          "pattern": "^S-[0-9]+$",
+          "description": "Solution-level queue item ID (S-1, S-2, ...)"
+        },
+        "issue_id": {
+          "type": "string",
+          "description": "Source issue ID"
+        },
+        "solution_id": {
+          "type": "string",
+          "description": "Bound solution ID"
+        },
+        "status": {
+          "type": "string",
+          "enum": ["pending", "ready", "executing", "completed", "failed", "blocked"],
+          "default": "pending"
+        },
+        "task_count": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Number of tasks in this solution"
+        },
+        "files_touched": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "All files modified by this solution"
+        },
+        "execution_order": {
+          "type": "integer",
+          "description": "Order in execution sequence"
+        },
+        "execution_group": {
+          "type": "string",
+          "description": "Parallel (P*) or Sequential (S*) group ID"
+        },
+        "depends_on": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Solution IDs this item depends on"
+        },
+        "semantic_priority": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1,
+          "description": "Semantic importance score (0.0-1.0)"
+        },
+        "queued_at": { "type": "string", "format": "date-time" },
+        "started_at": { "type": "string", "format": "date-time" },
+        "completed_at": { "type": "string", "format": "date-time" },
+        "result": {
+          "type": "object",
+          "properties": {
+            "summary": { "type": "string" },
+            "files_modified": { "type": "array", "items": { "type": "string" } },
+            "tasks_completed": { "type": "integer" },
+            "commit_hashes": { "type": "array", "items": { "type": "string" } }
+          }
+        },
+        "failure_reason": { "type": "string" }
+      }
+    },
+    "taskItem": {
+      "type": "object",
+      "required": ["item_id", "issue_id", "solution_id", "task_id", "status"],
+      "properties": {
+        "item_id": {
+          "type": "string",
+          "pattern": "^T-[0-9]+$",
+          "description": "Task-level queue item ID (T-1, T-2, ...)"
+        },
+        "issue_id": { "type": "string" },
+        "solution_id": { "type": "string" },
+        "task_id": { "type": "string" },
+        "status": {
+          "type": "string",
+          "enum": ["pending", "ready", "executing", "completed", "failed", "blocked"],
+          "default": "pending"
+        },
+        "execution_order": { "type": "integer" },
+        "execution_group": { "type": "string" },
+        "depends_on": { "type": "array", "items": { "type": "string" } },
+        "semantic_priority": { "type": "number", "minimum": 0, "maximum": 1 },
+        "queued_at": { "type": "string", "format": "date-time" },
+        "started_at": { "type": "string", "format": "date-time" },
+        "completed_at": { "type": "string", "format": "date-time" },
+        "result": {
+          "type": "object",
+          "properties": {
+            "files_modified": { "type": "array", "items": { "type": "string" } },
+            "files_created": { "type": "array", "items": { "type": "string" } },
+            "summary": { "type": "string" },
+            "commit_hash": { "type": "string" }
+          }
+        },
+        "failure_reason": { "type": "string" }
+      }
+    },
+    "conflict": {
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["file_conflict", "dependency_conflict", "resource_conflict"]
+        },
+        "file": {
+          "type": "string",
+          "description": "Conflicting file path"
+        },
+        "solutions": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Solution IDs involved (for solution-level queues)"
+        },
+        "tasks": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Task IDs involved (for task-level queues)"
+        },
+        "resolution": {
+          "type": "string",
+          "enum": ["sequential", "merge", "manual"]
+        },
+        "resolution_order": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Execution order to resolve conflict"
+        },
+        "rationale": {
+          "type": "string",
+          "description": "Explanation of resolution decision"
+        },
+        "resolved": {
+          "type": "boolean",
+          "default": false
+        }
+      }
+    },
+    "executionGroup": {
+      "type": "object",
+      "required": ["id", "type"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "pattern": "^[PS][0-9]+$",
+          "description": "Group ID (P1, P2 for parallel, S1, S2 for sequential)"
+        },
+        "type": {
+          "type": "string",
+          "enum": ["parallel", "sequential"]
+        },
+        "solutions": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Solution IDs in this group"
+        },
+        "tasks": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Task IDs in this group (legacy)"
+        },
+        "solution_count": {
+          "type": "integer",
+          "description": "Number of solutions in group"
+        },
+        "task_count": {
+          "type": "integer",
+          "description": "Number of tasks in group (legacy)"
+        }
+      }
+    }
+  }
+}

.ccw/workflows/cli-templates/schemas/registry-schema.json

@@ -0,0 +1,94 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Issue Registry Schema",
+  "description": "Global registry of all issues and their solutions",
+  "type": "object",
+  "properties": {
+    "issues": {
+      "type": "array",
+      "description": "List of registered issues",
+      "items": {
+        "type": "object",
+        "required": ["id", "title", "status", "created_at"],
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Issue ID (e.g., GH-123, TEXT-xxx)"
+          },
+          "title": {
+            "type": "string"
+          },
+          "status": {
+            "type": "string",
+            "enum": ["registered", "planning", "planned", "queued", "executing", "completed", "failed", "paused"],
+            "default": "registered"
+          },
+          "priority": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 5,
+            "default": 3
+          },
+          "solution_count": {
+            "type": "integer",
+            "default": 0,
+            "description": "Number of candidate solutions"
+          },
+          "bound_solution_id": {
+            "type": "string",
+            "description": "ID of the bound solution (null if none bound)"
+          },
+          "source": {
+            "type": "string",
+            "enum": ["github", "text", "file"],
+            "description": "Source of the issue"
+          },
+          "source_url": {
+            "type": "string",
+            "description": "Original source URL (for GitHub issues)"
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "updated_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "planned_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "queued_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "completed_at": {
+            "type": "string",
+            "format": "date-time"
+          }
+        }
+      }
+    },
+    "_metadata": {
+      "type": "object",
+      "properties": {
+        "version": { "type": "string", "default": "1.0" },
+        "total_issues": { "type": "integer" },
+        "by_status": {
+          "type": "object",
+          "properties": {
+            "registered": { "type": "integer" },
+            "planning": { "type": "integer" },
+            "planned": { "type": "integer" },
+            "queued": { "type": "integer" },
+            "executing": { "type": "integer" },
+            "completed": { "type": "integer" },
+            "failed": { "type": "integer" }
+          }
+        },
+        "last_updated": { "type": "string", "format": "date-time" }
+      }
+    }
+  }
+}

.ccw/workflows/cli-templates/schemas/review-deep-dive-results-schema.json

@@ -0,0 +1,82 @@
+[
+  {
+    "finding_id": "sec-001-a1b2c3d4",
+    "original_dimension": "security",
+    "iteration": 1,
+    "analysis_timestamp": "2025-01-25T14:40:15Z",
+    "cli_tool_used": "gemini",
+    "root_cause": {
+      "summary": "Legacy code from v1 migration, pre-ORM implementation",
+      "details": "Query builder was ported from old codebase without security review. Team unaware of injection risks in string concatenation pattern. Code review at migration time focused on functionality, not security.",
+      "affected_scope": "All query-builder.ts methods using string template literals (15 methods total)",
+      "similar_patterns": [
+        "src/database/user-queries.ts:buildEmailQuery",
+        "src/database/order-queries.ts:buildOrderSearch"
+      ]
+    },
+    "remediation_plan": {
+      "approach": "Migrate to ORM prepared statements with input validation layer",
+      "priority": "P0 - Critical (security vulnerability)",
+      "estimated_effort": "4 hours development + 2 hours testing",
+      "risk_level": "low",
+      "steps": [
+        {
+          "step": 1,
+          "action": "Replace direct string concatenation with ORM query builder",
+          "files": ["src/database/query-builder.ts:buildUserQuery:140-150"],
+          "commands": [
+            "Replace: const query = `SELECT * FROM users WHERE id = ${userId}`;",
+            "With: return db('users').where('id', userId).first();"
+          ],
+          "rationale": "ORM automatically parameterizes queries, eliminating injection risk",
+          "validation": "Run: npm test -- src/database/query-builder.test.ts"
+        },
+        {
+          "step": 2,
+          "action": "Add input validation layer before ORM",
+          "files": ["src/database/validators.ts:validateUserId:NEW"],
+          "commands": [
+            "Create validator: export function validateUserId(id: unknown): number { ... }",
+            "Add schema: z.number().positive().int()"
+          ],
+          "rationale": "Defense in depth - validate types and ranges before database layer",
+          "validation": "Run: npm test -- src/database/validators.test.ts"
+        },
+        {
+          "step": 3,
+          "action": "Apply pattern to all 15 similar methods",
+          "files": ["src/database/query-builder.ts:ALL_METHODS"],
+          "commands": ["Bulk replace string templates with ORM syntax"],
+          "rationale": "Prevent similar vulnerabilities in other query methods",
+          "validation": "Run: npm test -- src/database/"
+        }
+      ],
+      "rollback_strategy": "Git commit before each step, revert if tests fail. Staged rollout: dev → staging → production with monitoring."
+    },
+    "impact_assessment": {
+      "files_affected": [
+        "src/database/query-builder.ts (modify)",
+        "src/database/validators.ts (new)",
+        "src/database/user-queries.ts (modify)",
+        "src/database/order-queries.ts (modify)"
+      ],
+      "tests_required": [
+        "src/database/query-builder.test.ts (update existing)",
+        "src/database/validators.test.ts (new)",
+        "integration/security/sql-injection.test.ts (new)"
+      ],
+      "breaking_changes": false,
+      "dependencies_updated": ["knex@2.5.1 (ORM library)"],
+      "deployment_notes": "No downtime required. Database migrations not needed."
+    },
+    "reassessed_severity": "high",
+    "severity_change_reason": "Found existing WAF rules partially mitigate risk in production. Input validation at API gateway layer provides additional defense. Downgrade from critical to high, but still requires immediate fix.",
+    "confidence_score": 0.95,
+    "references": [
+      "Project ORM migration guide: docs/architecture/orm-guide.md",
+      "Knex.js parameterization: https://knexjs.org/guide/query-builder.html#where",
+      "Similar incident: TICKET-1234 (previous SQL injection fix)"
+    ],
+    "status": "remediation_plan_ready"
+  }
+]

.ccw/workflows/cli-templates/schemas/review-dimension-results-schema.json

@@ -0,0 +1,51 @@
+[
+  {
+    "dimension": "security",
+    "review_id": "review-20250125-143022",
+    "analysis_timestamp": "2025-01-25T14:30:22Z",
+    "cli_tool_used": "gemini",
+    "model": "gemini-2.5-pro",
+    "analysis_duration_ms": 2145000,
+    "summary": {
+      "total_findings": 15,
+      "critical": 2,
+      "high": 4,
+      "medium": 6,
+      "low": 3,
+      "files_analyzed": 47,
+      "lines_reviewed": 8932
+    },
+    "findings": [
+      {
+        "id": "sec-001-a1b2c3d4",
+        "title": "SQL Injection vulnerability in user query",
+        "severity": "critical",
+        "category": "injection",
+        "description": "Direct string concatenation in SQL query allows injection attacks. User input is not sanitized before query execution.",
+        "file": "src/database/query-builder.ts",
+        "line": 145,
+        "snippet": "const query = `SELECT * FROM users WHERE id = ${userId}`;",
+        "recommendation": "Use parameterized queries: db.query('SELECT * FROM users WHERE id = ?', [userId])",
+        "references": [
+          "OWASP Top 10 - A03:2021 Injection",
+          "https://owasp.org/www-community/attacks/SQL_Injection"
+        ],
+        "impact": "Potential data breach, unauthorized access to user records, data manipulation",
+        "metadata": {
+          "cwe_id": "CWE-89",
+          "owasp_category": "A03:2021-Injection"
+        },
+        "iteration": 0,
+        "status": "pending_remediation",
+        "cross_references": []
+      }
+    ],
+    "cross_references": [
+      {
+        "finding_id": "sec-001-a1b2c3d4",
+        "related_dimensions": ["quality", "architecture"],
+        "reason": "Same file flagged in multiple dimensions"
+      }
+    ]
+  }
+]

.ccw/workflows/cli-templates/schemas/solution-schema.json

@@ -0,0 +1,166 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Issue Solution Schema",
+  "description": "Schema for solution registered to an issue",
+  "type": "object",
+  "required": ["id", "tasks", "is_bound", "created_at"],
+  "properties": {
+    "id": {
+      "type": "string",
+      "description": "Unique solution identifier: SOL-{issue-id}-{4-char-uid} where uid is 4 alphanumeric chars",
+      "pattern": "^SOL-.+-[a-z0-9]{4}$",
+      "examples": ["SOL-GH-123-a7x9", "SOL-ISS-20251229-001-b2k4"]
+    },
+    "description": {
+      "type": "string",
+      "description": "High-level summary of the solution"
+    },
+    "approach": {
+      "type": "string",
+      "description": "Technical approach or strategy"
+    },
+    "tasks": {
+      "type": "array",
+      "description": "Task breakdown for this solution",
+      "items": {
+        "type": "object",
+        "required": ["id", "title", "scope", "action", "implementation", "acceptance"],
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^T[0-9]+$"
+          },
+          "title": {
+            "type": "string",
+            "description": "Action verb + target"
+          },
+          "scope": {
+            "type": "string",
+            "description": "Module path or feature area"
+          },
+          "action": {
+            "type": "string",
+            "enum": ["Create", "Update", "Implement", "Refactor", "Add", "Delete", "Configure", "Test", "Fix"]
+          },
+          "description": {
+            "type": "string",
+            "description": "1-2 sentences describing what to implement"
+          },
+          "modification_points": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "file": { "type": "string" },
+                "target": { "type": "string" },
+                "change": { "type": "string" }
+              }
+            }
+          },
+          "implementation": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Step-by-step implementation guide"
+          },
+          "test": {
+            "type": "object",
+            "description": "Test requirements",
+            "properties": {
+              "unit": { "type": "array", "items": { "type": "string" } },
+              "integration": { "type": "array", "items": { "type": "string" } },
+              "commands": { "type": "array", "items": { "type": "string" } },
+              "coverage_target": { "type": "number" }
+            }
+          },
+          "regression": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Regression check points"
+          },
+          "acceptance": {
+            "type": "object",
+            "description": "Acceptance criteria & verification",
+            "required": ["criteria", "verification"],
+            "properties": {
+              "criteria": { "type": "array", "items": { "type": "string" } },
+              "verification": { "type": "array", "items": { "type": "string" } },
+              "manual_checks": { "type": "array", "items": { "type": "string" } }
+            }
+          },
+          "commit": {
+            "type": "object",
+            "description": "Commit specification",
+            "properties": {
+              "type": { "type": "string", "enum": ["feat", "fix", "refactor", "test", "docs", "chore"] },
+              "scope": { "type": "string" },
+              "message_template": { "type": "string" },
+              "breaking": { "type": "boolean" }
+            }
+          },
+          "depends_on": {
+            "type": "array",
+            "items": { "type": "string" },
+            "default": [],
+            "description": "Task IDs this task depends on"
+          },
+          "estimated_minutes": {
+            "type": "integer",
+            "description": "Estimated time to complete"
+          },
+          "status": {
+            "type": "string",
+            "description": "Task status (optional, for tracking)"
+          },
+          "priority": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 5,
+            "default": 3
+          }
+        }
+      }
+    },
+    "exploration_context": {
+      "type": "object",
+      "description": "ACE exploration results",
+      "properties": {
+        "project_structure": { "type": "string" },
+        "relevant_files": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "patterns": { "type": "string" },
+        "integration_points": { "type": "string" }
+      }
+    },
+    "analysis": {
+      "type": "object",
+      "description": "Solution risk assessment",
+      "properties": {
+        "risk": { "type": "string", "enum": ["low", "medium", "high"] },
+        "impact": { "type": "string", "enum": ["low", "medium", "high"] },
+        "complexity": { "type": "string", "enum": ["low", "medium", "high"] }
+      }
+    },
+    "score": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1,
+      "description": "Solution quality score (0.0-1.0)"
+    },
+    "is_bound": {
+      "type": "boolean",
+      "default": false,
+      "description": "Whether this solution is bound to the issue"
+    },
+    "created_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "bound_at": {
+      "type": "string",
+      "format": "date-time",
+      "description": "When this solution was bound to the issue"
+    }
+  }
+}

.ccw/workflows/cli-templates/schemas/verify-json-schema.json

@@ -0,0 +1,158 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Plan Verification Findings Schema",
+  "description": "Schema for plan verification findings output from cli-explore-agent",
+  "type": "object",
+  "required": [
+    "session_id",
+    "timestamp",
+    "verification_tiers_completed",
+    "findings",
+    "summary"
+  ],
+  "properties": {
+    "session_id": {
+      "type": "string",
+      "description": "Workflow session ID (e.g., WFS-20250127-143000)",
+      "pattern": "^WFS-[0-9]{8}-[0-9]{6}$"
+    },
+    "timestamp": {
+      "type": "string",
+      "description": "ISO 8601 timestamp when verification was completed",
+      "format": "date-time"
+    },
+    "verification_tiers_completed": {
+      "type": "array",
+      "description": "List of verification tiers completed (e.g., ['Tier 1', 'Tier 2'])",
+      "items": {
+        "type": "string",
+        "enum": ["Tier 1", "Tier 2", "Tier 3", "Tier 4"]
+      },
+      "minItems": 1,
+      "maxItems": 4
+    },
+    "findings": {
+      "type": "array",
+      "description": "Array of all findings across all dimensions",
+      "items": {
+        "type": "object",
+        "required": [
+          "id",
+          "dimension",
+          "dimension_name",
+          "severity",
+          "location",
+          "summary",
+          "recommendation"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Unique finding ID prefixed by severity (C1, H1, M1, L1)",
+            "pattern": "^[CHML][0-9]+$"
+          },
+          "dimension": {
+            "type": "string",
+            "description": "Verification dimension identifier",
+            "enum": ["A", "B", "C", "D", "E", "F", "G", "H"]
+          },
+          "dimension_name": {
+            "type": "string",
+            "description": "Human-readable dimension name",
+            "enum": [
+              "User Intent Alignment",
+              "Requirements Coverage Analysis",
+              "Consistency Validation",
+              "Dependency Integrity",
+              "Synthesis Alignment",
+              "Task Specification Quality",
+              "Duplication Detection",
+              "Feasibility Assessment"
+            ]
+          },
+          "severity": {
+            "type": "string",
+            "description": "Severity level of the finding",
+            "enum": ["CRITICAL", "HIGH", "MEDIUM", "LOW"]
+          },
+          "location": {
+            "type": "array",
+            "description": "Array of locations where issue was found (e.g., 'IMPL_PLAN.md:L45', 'task:IMPL-1.2', 'synthesis:FR-03')",
+            "items": {
+              "type": "string"
+            },
+            "minItems": 1
+          },
+          "summary": {
+            "type": "string",
+            "description": "Concise summary of the issue (1-2 sentences)",
+            "minLength": 10,
+            "maxLength": 500
+          },
+          "recommendation": {
+            "type": "string",
+            "description": "Actionable recommendation to resolve the issue",
+            "minLength": 10,
+            "maxLength": 500
+          }
+        }
+      }
+    },
+    "summary": {
+      "type": "object",
+      "description": "Aggregate summary of verification results",
+      "required": [
+        "critical_count",
+        "high_count",
+        "medium_count",
+        "low_count",
+        "total_findings",
+        "coverage_percentage",
+        "recommendation"
+      ],
+      "properties": {
+        "critical_count": {
+          "type": "integer",
+          "description": "Number of critical severity findings",
+          "minimum": 0
+        },
+        "high_count": {
+          "type": "integer",
+          "description": "Number of high severity findings",
+          "minimum": 0
+        },
+        "medium_count": {
+          "type": "integer",
+          "description": "Number of medium severity findings",
+          "minimum": 0
+        },
+        "low_count": {
+          "type": "integer",
+          "description": "Number of low severity findings",
+          "minimum": 0
+        },
+        "total_findings": {
+          "type": "integer",
+          "description": "Total number of findings",
+          "minimum": 0
+        },
+        "coverage_percentage": {
+          "type": "number",
+          "description": "Percentage of synthesis requirements covered by tasks (0-100)",
+          "minimum": 0,
+          "maximum": 100
+        },
+        "recommendation": {
+          "type": "string",
+          "description": "Quality gate recommendation",
+          "enum": [
+            "BLOCK_EXECUTION",
+            "PROCEED_WITH_FIXES",
+            "PROCEED_WITH_CAUTION",
+            "PROCEED"
+          ]
+        }
+      }
+    }
+  }
+}

.ccw/workflows/cli-templates/ui-design/systems/animation-tokens.json

@@ -0,0 +1,247 @@
+{
+  "$schema": "https://tr.designtokens.org/format/",
+
+  "duration": {
+    "$type": "duration",
+    "instant": { "$value": "0ms" },
+    "fast": { "$value": "150ms" },
+    "normal": { "$value": "300ms" },
+    "slow": { "$value": "500ms" },
+    "slower": { "$value": "1000ms" }
+  },
+
+  "easing": {
+    "$type": "cubicBezier",
+    "linear": { "$value": "linear" },
+    "ease-in": { "$value": "cubic-bezier(0.4, 0, 1, 1)" },
+    "ease-out": { "$value": "cubic-bezier(0, 0, 0.2, 1)" },
+    "ease-in-out": { "$value": "cubic-bezier(0.4, 0, 0.2, 1)" },
+    "spring": { "$value": "cubic-bezier(0.68, -0.55, 0.265, 1.55)" },
+    "bounce": { "$value": "cubic-bezier(0.68, -0.6, 0.32, 1.6)" }
+  },
+
+  "keyframes": {
+    "_comment_pattern": "Define pairs (in/out, open/close, enter/exit)",
+    "_comment_required": "Required keyframes for components",
+
+    "fade-in": {
+      "0%": { "opacity": "0" },
+      "100%": { "opacity": "1" }
+    },
+    "fade-out": {
+      "_comment": "reverse of fade-in",
+      "0%": { "opacity": "1" },
+      "100%": { "opacity": "0" }
+    },
+
+    "slide-up": {
+      "0%": { "transform": "translateY(10px)", "opacity": "0" },
+      "100%": { "transform": "translateY(0)", "opacity": "1" }
+    },
+    "slide-down": {
+      "_comment": "reverse direction",
+      "0%": { "transform": "translateY(0)", "opacity": "1" },
+      "100%": { "transform": "translateY(10px)", "opacity": "0" }
+    },
+
+    "scale-in": {
+      "0%": { "transform": "scale(0.95)", "opacity": "0" },
+      "100%": { "transform": "scale(1)", "opacity": "1" }
+    },
+    "scale-out": {
+      "_comment": "reverse of scale-in",
+      "0%": { "transform": "scale(1)", "opacity": "1" },
+      "100%": { "transform": "scale(0.95)", "opacity": "0" }
+    },
+
+    "accordion-down": {
+      "0%": { "height": "0", "opacity": "0" },
+      "100%": { "height": "var(--radix-accordion-content-height)", "opacity": "1" }
+    },
+    "accordion-up": {
+      "_comment": "reverse",
+      "0%": { "height": "var(--radix-accordion-content-height)", "opacity": "1" },
+      "100%": { "height": "0", "opacity": "0" }
+    },
+
+    "dialog-open": {
+      "0%": { "transform": "translate(-50%, -48%) scale(0.96)", "opacity": "0" },
+      "100%": { "transform": "translate(-50%, -50%) scale(1)", "opacity": "1" }
+    },
+    "dialog-close": {
+      "_comment": "reverse",
+      "0%": { "transform": "translate(-50%, -50%) scale(1)", "opacity": "1" },
+      "100%": { "transform": "translate(-50%, -48%) scale(0.96)", "opacity": "0" }
+    },
+
+    "dropdown-open": {
+      "0%": { "transform": "scale(0.95) translateY(-4px)", "opacity": "0" },
+      "100%": { "transform": "scale(1) translateY(0)", "opacity": "1" }
+    },
+    "dropdown-close": {
+      "_comment": "reverse",
+      "0%": { "transform": "scale(1) translateY(0)", "opacity": "1" },
+      "100%": { "transform": "scale(0.95) translateY(-4px)", "opacity": "0" }
+    },
+
+    "toast-enter": {
+      "0%": { "transform": "translateX(100%)", "opacity": "0" },
+      "100%": { "transform": "translateX(0)", "opacity": "1" }
+    },
+    "toast-exit": {
+      "_comment": "reverse",
+      "0%": { "transform": "translateX(0)", "opacity": "1" },
+      "100%": { "transform": "translateX(100%)", "opacity": "0" }
+    },
+
+    "spin": {
+      "0%": { "transform": "rotate(0deg)" },
+      "100%": { "transform": "rotate(360deg)" }
+    },
+    "pulse": {
+      "0%, 100%": { "opacity": "1" },
+      "50%": { "opacity": "0.5" }
+    }
+  },
+
+  "interactions": {
+    "_comment_pattern": "Define for each interactive component state",
+    "_structure": {
+      "property": "string - CSS properties (comma-separated)",
+      "duration": "{duration.*}",
+      "easing": "{easing.*}"
+    },
+
+    "button-hover": {
+      "property": "background-color, transform",
+      "duration": "{duration.fast}",
+      "easing": "{easing.ease-out}"
+    },
+    "button-active": {
+      "property": "transform",
+      "duration": "{duration.instant}",
+      "easing": "{easing.ease-in}"
+    },
+    "card-hover": {
+      "property": "box-shadow, transform",
+      "duration": "{duration.normal}",
+      "easing": "{easing.ease-in-out}"
+    },
+    "input-focus": {
+      "property": "border-color, box-shadow",
+      "duration": "{duration.fast}",
+      "easing": "{easing.ease-out}"
+    },
+    "dropdown-toggle": {
+      "property": "opacity, transform",
+      "duration": "{duration.fast}",
+      "easing": "{easing.ease-out}"
+    },
+    "accordion-toggle": {
+      "property": "height, opacity",
+      "duration": "{duration.normal}",
+      "easing": "{easing.ease-in-out}"
+    },
+    "dialog-toggle": {
+      "property": "opacity, transform",
+      "duration": "{duration.normal}",
+      "easing": "{easing.spring}"
+    },
+    "tabs-switch": {
+      "property": "color, border-color",
+      "duration": "{duration.fast}",
+      "easing": "{easing.ease-in-out}"
+    }
+  },
+
+  "transitions": {
+    "default": { "$value": "all {duration.normal} {easing.ease-in-out}" },
+    "colors": { "$value": "color {duration.fast} {easing.linear}, background-color {duration.fast} {easing.linear}" },
+    "transform": { "$value": "transform {duration.normal} {easing.spring}" },
+    "opacity": { "$value": "opacity {duration.fast} {easing.linear}" },
+    "all-smooth": { "$value": "all {duration.slow} {easing.ease-in-out}" }
+  },
+
+  "component_animations": {
+    "_comment_pattern": "Map each component to its animations - MUST match design-tokens.json component list",
+    "_structure": {
+      "stateOrInteraction": {
+        "animation": "keyframe-name {duration.*} {easing.*} OR none",
+        "transition": "{interactions.*} OR none"
+      }
+    },
+
+    "button": {
+      "hover": { "animation": "none", "transition": "{interactions.button-hover}" },
+      "active": { "animation": "none", "transition": "{interactions.button-active}" }
+    },
+    "card": {
+      "hover": { "animation": "none", "transition": "{interactions.card-hover}" }
+    },
+    "input": {
+      "focus": { "animation": "none", "transition": "{interactions.input-focus}" }
+    },
+    "dialog": {
+      "open": { "animation": "dialog-open {duration.normal} {easing.spring}" },
+      "close": { "animation": "dialog-close {duration.normal} {easing.ease-in}" }
+    },
+    "dropdown": {
+      "open": { "animation": "dropdown-open {duration.fast} {easing.ease-out}" },
+      "close": { "animation": "dropdown-close {duration.fast} {easing.ease-in}" }
+    },
+    "toast": {
+      "enter": { "animation": "toast-enter {duration.normal} {easing.ease-out}" },
+      "exit": { "animation": "toast-exit {duration.normal} {easing.ease-in}" }
+    },
+    "accordion": {
+      "open": { "animation": "accordion-down {duration.normal} {easing.ease-out}" },
+      "close": { "animation": "accordion-up {duration.normal} {easing.ease-in}" }
+    },
+    "_comment_missing": "Add mappings for: tabs, switch, checkbox, badge, alert"
+  },
+
+  "accessibility": {
+    "prefers_reduced_motion": {
+      "duration": "0ms",
+      "keyframes": {},
+      "note": "Disable animations when user prefers reduced motion",
+      "css_rule": "@media (prefers-reduced-motion: reduce) { *, *::before, *::after { animation-duration: 0.01ms !important; animation-iteration-count: 1 !important; transition-duration: 0.01ms !important; } }"
+    }
+  },
+
+  "_metadata": {
+    "version": "string",
+    "created": "ISO timestamp",
+    "source": "code-import|explore|text",
+    "code_snippets": [
+      {
+        "animation_name": "string - keyframe/transition name",
+        "source_file": "string - absolute path",
+        "line_start": "number",
+        "line_end": "number",
+        "snippet": "string - complete @keyframes or transition code",
+        "context_type": "css-keyframes|css-transition|js-animation|scss-animation|etc"
+      }
+    ]
+  },
+
+  "_field_rules": {
+    "schema": "$schema MUST reference W3C Design Tokens format specification",
+    "duration_wrapper": "All duration values MUST use $value wrapper with ms units",
+    "easing_wrapper": "All easing values MUST use $value wrapper with standard CSS easing or cubic-bezier()",
+    "keyframes": "keyframes MUST define complete component state animations (open/close, enter/exit)",
+    "interactions_refs": "interactions MUST reference duration and easing using {token.path} syntax",
+    "component_mapping": "component_animations MUST map component states to specific keyframes and transitions",
+    "component_coverage": "component_animations MUST be defined for all interactive and stateful components",
+    "transitions_wrapper": "transitions MUST use $value wrapper for complete transition definitions",
+    "accessibility": "accessibility.prefers_reduced_motion MUST be included with CSS media query rule",
+    "code_snippets": "_metadata.code_snippets ONLY present in Code Import mode"
+  },
+
+  "_animation_component_integration": {
+    "requirement": "Each component in design-tokens.json component section MUST have corresponding entry in component_animations",
+    "state_based": "State-based animations (dialog.open, accordion.close) MUST use keyframe animations",
+    "interaction": "Interaction animations (button.hover, input.focus) MUST use transitions",
+    "consistency": "All animation references use {token.path} syntax for consistency"
+  }
+}

.ccw/workflows/cli-templates/ui-design/systems/design-tokens.json

@@ -0,0 +1,342 @@
+{
+  "$schema": "https://tr.designtokens.org/format/",
+  "name": "string - Token set name",
+  "description": "string - Token set description",
+
+  "color": {
+    "background": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" }, "$description": "optional" },
+    "foreground": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+    "card": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+    "card-foreground": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+    "border": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+    "input": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+    "ring": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+
+    "interactive": {
+      "primary": {
+        "default": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "hover": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "active": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "disabled": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "foreground": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } }
+      },
+      "secondary": {
+        "_comment": "Same structure as primary",
+        "default": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "hover": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "active": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "disabled": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "foreground": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } }
+      },
+      "accent": {
+        "_comment": "Same structure (no disabled state)",
+        "default": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "hover": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "active": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "foreground": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } }
+      },
+      "destructive": {
+        "_comment": "Same structure (no active/disabled states)",
+        "default": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "hover": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+        "foreground": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } }
+      }
+    },
+
+    "muted": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+    "muted-foreground": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+
+    "chart": {
+      "1": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+      "2": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+      "3": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+      "4": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+      "5": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } }
+    },
+
+    "sidebar": {
+      "background": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+      "foreground": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+      "primary": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+      "primary-foreground": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+      "accent": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+      "accent-foreground": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+      "border": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } },
+      "ring": { "$type": "color", "$value": { "light": "oklch(...)", "dark": "oklch(...)" } }
+    }
+  },
+
+  "typography": {
+    "font_families": {
+      "sans": "string - 'Font Name', fallback1, fallback2",
+      "serif": "string",
+      "mono": "string"
+    },
+    "font_sizes": {
+      "xs": "0.75rem",
+      "sm": "0.875rem",
+      "base": "1rem",
+      "lg": "1.125rem",
+      "xl": "1.25rem",
+      "2xl": "1.5rem",
+      "3xl": "1.875rem",
+      "4xl": "2.25rem"
+    },
+    "line_heights": {
+      "tight": "number",
+      "normal": "number",
+      "relaxed": "number"
+    },
+    "letter_spacing": {
+      "tight": "string",
+      "normal": "string",
+      "wide": "string"
+    },
+    "combinations": [
+      {
+        "name": "h1|h2|h3|h4|h5|h6|body|caption",
+        "font_family": "sans|serif|mono",
+        "font_size": "string - reference to font_sizes",
+        "font_weight": "number - 400|500|600|700",
+        "line_height": "string",
+        "letter_spacing": "string"
+      }
+    ]
+  },
+
+  "spacing": {
+    "0": "0",
+    "1": "0.25rem",
+    "2": "0.5rem",
+    "3": "0.75rem",
+    "4": "1rem",
+    "6": "1.5rem",
+    "8": "2rem",
+    "12": "3rem",
+    "16": "4rem",
+    "20": "5rem",
+    "24": "6rem",
+    "32": "8rem",
+    "40": "10rem",
+    "48": "12rem",
+    "56": "14rem",
+    "64": "16rem"
+  },
+
+  "opacity": {
+    "disabled": "0.5",
+    "hover": "0.8",
+    "active": "1"
+  },
+
+  "shadows": {
+    "2xs": "string - CSS shadow value",
+    "xs": "string",
+    "sm": "string",
+    "DEFAULT": "string",
+    "md": "string",
+    "lg": "string",
+    "xl": "string",
+    "2xl": "string"
+  },
+
+  "border_radius": {
+    "sm": "string - calc() or fixed",
+    "md": "string",
+    "lg": "string",
+    "xl": "string",
+    "DEFAULT": "string"
+  },
+
+  "breakpoints": {
+    "sm": "640px",
+    "md": "768px",
+    "lg": "1024px",
+    "xl": "1280px",
+    "2xl": "1536px"
+  },
+
+  "component": {
+    "_comment_pattern": "COMPONENT PATTERN - Apply to: button, card, input, dialog, dropdown, toast, accordion, tabs, switch, checkbox, badge, alert",
+    "_example_button": {
+      "$type": "component",
+      "base": {
+        "_comment": "Layout properties using camelCase",
+        "display": "inline-flex|flex|block",
+        "alignItems": "center",
+        "borderRadius": "{border_radius.md}",
+        "transition": "{transitions.default}"
+      },
+      "size": {
+        "small": { "height": "32px", "padding": "{spacing.2} {spacing.3}", "fontSize": "{typography.font_sizes.xs}" },
+        "default": { "height": "40px", "padding": "{spacing.2} {spacing.4}" },
+        "large": { "height": "48px", "padding": "{spacing.3} {spacing.6}", "fontSize": "{typography.font_sizes.base}" }
+      },
+      "variant": {
+        "variantName": {
+          "default": { "backgroundColor": "{color.interactive.primary.default}", "color": "{color.interactive.primary.foreground}" },
+          "hover": { "backgroundColor": "{color.interactive.primary.hover}" },
+          "active": { "backgroundColor": "{color.interactive.primary.active}" },
+          "disabled": { "backgroundColor": "{color.interactive.primary.disabled}", "opacity": "{opacity.disabled}", "cursor": "not-allowed" },
+          "focus": { "outline": "2px solid {color.ring}", "outlineOffset": "2px" }
+        }
+      },
+      "state": {
+        "_comment": "For stateful components (dialog, accordion, etc.)",
+        "open": { "animation": "{animation.name.component-open} {animation.duration.normal} {animation.easing.ease-out}" },
+        "closed": { "animation": "{animation.name.component-close} {animation.duration.normal} {animation.easing.ease-in}" }
+      }
+    }
+  },
+
+  "elevation": {
+    "$type": "elevation",
+    "base": { "$value": "0" },
+    "overlay": { "$value": "40" },
+    "dropdown": { "$value": "50" },
+    "dialog": { "$value": "50" },
+    "tooltip": { "$value": "60" }
+  },
+
+  "_metadata": {
+    "version": "string - W3C version or custom version",
+    "created": "ISO timestamp - 2024-01-01T00:00:00Z",
+    "source": "code-import|explore|text",
+    "theme_colors_guide": {
+      "description": "Theme colors are the core brand identity colors that define the visual hierarchy and emotional tone of the design system",
+      "primary": {
+        "role": "Main brand color",
+        "usage": "Primary actions (CTAs, key interactive elements, navigation highlights, primary buttons)",
+        "contrast_requirement": "WCAG AA - 4.5:1 for text, 3:1 for UI components"
+      },
+      "secondary": {
+        "role": "Supporting brand color",
+        "usage": "Secondary actions and complementary elements (less prominent buttons, secondary navigation, supporting features)",
+        "principle": "Should complement primary without competing for attention"
+      },
+      "accent": {
+        "role": "Highlight color for emphasis",
+        "usage": "Attention-grabbing elements used sparingly (badges, notifications, special promotions, highlights)",
+        "principle": "Should create strong visual contrast to draw focus"
+      },
+      "destructive": {
+        "role": "Error and destructive action color",
+        "usage": "Delete buttons, error messages, critical warnings",
+        "principle": "Must signal danger or caution clearly"
+      },
+      "harmony_note": "All theme colors must work harmoniously together and align with brand identity. In multi-file extraction, prioritize definitions with semantic comments explaining brand intent."
+    },
+    "conflicts": [
+      {
+        "token_name": "string - which token has conflicts",
+        "category": "string - colors|typography|etc",
+        "definitions": [
+          {
+            "value": "string - token value",
+            "source_file": "string - absolute path",
+            "line_number": "number",
+            "context": "string - surrounding comment or null",
+            "semantic_intent": "string - interpretation of definition"
+          }
+        ],
+        "selected_value": "string - final chosen value",
+        "selection_reason": "string - why this value was chosen"
+      }
+    ],
+    "code_snippets": [
+      {
+        "category": "colors|typography|spacing|shadows|border_radius|component",
+        "token_name": "string - which token this snippet defines",
+        "source_file": "string - absolute path",
+        "line_start": "number",
+        "line_end": "number",
+        "snippet": "string - complete code block",
+        "context_type": "css-variable|css-class|js-object|scss-variable|etc"
+      }
+    ],
+    "usage_recommendations": {
+      "typography": {
+        "common_sizes": {
+          "small_text": "sm (0.875rem)",
+          "body_text": "base (1rem)",
+          "heading": "2xl-4xl"
+        },
+        "common_combinations": [
+          {
+            "name": "Heading + Body",
+            "heading": "2xl",
+            "body": "base",
+            "use_case": "Article sections"
+          }
+        ]
+      },
+      "spacing": {
+        "size_guide": {
+          "tight": "1-2 (0.25rem-0.5rem)",
+          "normal": "4-6 (1rem-1.5rem)",
+          "loose": "8-12 (2rem-3rem)"
+        },
+        "common_patterns": [
+          {
+            "pattern": "padding-4 margin-bottom-6",
+            "use_case": "Card content spacing",
+            "pixel_value": "1rem padding, 1.5rem margin"
+          }
+        ]
+      }
+    }
+  },
+
+  "_field_rules": {
+    "schema": "$schema MUST reference W3C Design Tokens format specification",
+    "colors": "All color values MUST use OKLCH format with light/dark mode values",
+    "types": "All tokens MUST include $type metadata (color, dimension, duration, component, elevation)",
+    "states": "Color tokens MUST include interactive states (default, hover, active, disabled) where applicable",
+    "fonts": "Typography font_families MUST include Google Fonts with fallback stacks",
+    "spacing": "Spacing MUST use systematic scale (multiples of 0.25rem base unit)",
+    "components": "Component definitions MUST be structured objects referencing other tokens via {token.path} syntax",
+    "component_states": "Component definitions MUST include state-based styling (default, hover, active, focus, disabled)",
+    "elevation": "elevation z-index values MUST be defined for layered components (overlay, dropdown, dialog, tooltip)",
+    "metadata_guide": "_metadata.theme_colors_guide RECOMMENDED in all modes to help users understand theme color roles and usage",
+    "metadata_conflicts": "_metadata.conflicts MANDATORY in Code Import mode when conflicting definitions detected",
+    "metadata_snippets": "_metadata.code_snippets ONLY present in Code Import mode",
+    "metadata_recommendations": "_metadata.usage_recommendations RECOMMENDED for universal components"
+  },
+
+  "_required_components": {
+    "_comment": "12+ components required, use pattern above",
+    "button": "5 variants (primary, secondary, destructive, outline, ghost) + 3 sizes + states (default, hover, active, disabled, focus)",
+    "card": "2 variants (default, interactive) + hover animations",
+    "input": "states (default, focus, disabled, error) + 3 sizes",
+    "dialog": "overlay + content + states (open, closed with animations)",
+    "dropdown": "trigger (references button) + content + item (with states) + states (open, closed)",
+    "toast": "2 variants (default, destructive) + states (enter, exit with animations)",
+    "accordion": "trigger + content + states (open, closed with animations)",
+    "tabs": "list + trigger (states: default, hover, active, disabled) + content",
+    "switch": "root + thumb + states (checked, disabled)",
+    "checkbox": "states (default, checked, disabled, focus)",
+    "badge": "4 variants (default, secondary, destructive, outline)",
+    "alert": "2 variants (default, destructive)"
+  },
+
+  "_token_reference_syntax": {
+    "_comment": "Use {token.path} to reference other tokens",
+    "examples": [
+      "{color.interactive.primary.default}",
+      "{spacing.4}",
+      "{typography.font_sizes.sm}"
+    ],
+    "resolution": "References are resolved during CSS generation",
+    "nested": "Supports nested references (e.g., {component.button.base})"
+  },
+
+  "_conflict_resolution_rules": {
+    "_comment": "Code Import Mode only",
+    "detect": "MUST detect when same token has different values across files",
+    "read": "MUST read semantic comments (/* ... */) surrounding definitions",
+    "prioritize": "MUST prioritize definitions with semantic intent over bare values",
+    "record": "MUST record ALL definitions in conflicts array, not just selected one",
+    "explain": "MUST explain selection_reason referencing semantic context",
+    "verify": "For core theme tokens (primary, secondary, accent): MUST verify selected value aligns with overall color scheme described in comments"
+  }
+}

.ccw/workflows/cli-templates/ui-design/systems/layout-templates.json

@@ -0,0 +1,145 @@
+{
+  "$schema": "https://tr.designtokens.org/format/",
+  "templates": [
+    {
+      "target": "string - page/component name (e.g., hero-section, product-card)",
+      "description": "string - layout description",
+      "component_type": "universal|specialized",
+      "device_type": "mobile|tablet|desktop|responsive",
+      "layout_strategy": "string - grid-3col|flex-row|stack|sidebar|etc",
+
+      "structure": {
+        "tag": "string - HTML5 semantic tag (header|nav|main|section|article|aside|footer|div|etc)",
+        "attributes": {
+          "class": "string - semantic class name",
+          "role": "string - ARIA role (navigation|main|complementary|etc)",
+          "aria-label": "string - ARIA label",
+          "aria-describedby": "string - ARIA describedby",
+          "data-state": "string - data attributes for state management (open|closed|etc)"
+        },
+        "layout": {
+          "_comment": "LAYOUT PROPERTIES ONLY - Use camelCase for property names",
+          "display": "grid|flex|block|inline-flex",
+          "grid-template-columns": "{spacing.*} or CSS value (repeat(3, 1fr))",
+          "grid-template-rows": "string",
+          "gap": "{spacing.*}",
+          "padding": "{spacing.*}",
+          "margin": "{spacing.*}",
+          "alignItems": "start|center|end|stretch",
+          "justifyContent": "start|center|end|space-between|space-around",
+          "flexDirection": "row|column",
+          "flexWrap": "wrap|nowrap",
+          "position": "relative|absolute|fixed|sticky",
+          "top": "string",
+          "right": "string",
+          "bottom": "string",
+          "left": "string",
+          "width": "string",
+          "height": "string",
+          "maxWidth": "string",
+          "minHeight": "string"
+        },
+        "responsive": {
+          "_comment": "ONLY properties that CHANGE at each breakpoint - NO repetition",
+          "sm": {
+            "grid-template-columns": "1fr",
+            "padding": "{spacing.4}"
+          },
+          "md": {
+            "grid-template-columns": "repeat(2, 1fr)",
+            "gap": "{spacing.6}"
+          },
+          "lg": {
+            "grid-template-columns": "repeat(3, 1fr)"
+          }
+        },
+        "children": [
+          {
+            "_comment": "Recursive structure - same fields as parent",
+            "tag": "string",
+            "attributes": {},
+            "layout": {},
+            "responsive": {},
+            "children": [],
+            "content": "string or {{placeholder}}"
+          }
+        ],
+        "content": "string - text content or {{placeholder}} for dynamic content"
+      },
+
+      "accessibility": {
+        "patterns": [
+          "string - ARIA patterns used (e.g., WAI-ARIA Tabs pattern, Dialog pattern)"
+        ],
+        "keyboard_navigation": [
+          "string - keyboard shortcuts (e.g., Tab/Shift+Tab navigation, Escape to close)"
+        ],
+        "focus_management": "string - focus trap strategy, initial focus target",
+        "screen_reader_notes": [
+          "string - screen reader announcements (e.g., Dialog opened, Tab selected)"
+        ]
+      },
+
+      "usage_guide": {
+        "common_sizes": {
+          "small": {
+            "dimensions": "string - e.g., px-3 py-1.5 (height: ~32px)",
+            "use_case": "string - Compact UI, mobile views"
+          },
+          "medium": {
+            "dimensions": "string - e.g., px-4 py-2 (height: ~40px)",
+            "use_case": "string - Default size for most contexts"
+          },
+          "large": {
+            "dimensions": "string - e.g., px-6 py-3 (height: ~48px)",
+            "use_case": "string - Prominent CTAs, hero sections"
+          }
+        },
+        "variant_recommendations": {
+          "variant_name": {
+            "description": "string - when to use this variant",
+            "typical_actions": ["string - action examples"]
+          }
+        },
+        "usage_context": [
+          "string - typical usage scenarios (e.g., Landing page hero, Product listing grid)"
+        ],
+        "accessibility_tips": [
+          "string - accessibility best practices (e.g., Ensure heading hierarchy, Add aria-label)"
+        ]
+      },
+
+      "extraction_metadata": {
+        "source": "code-import|explore|text",
+        "created": "ISO timestamp",
+        "code_snippets": [
+          {
+            "component_name": "string - which layout component",
+            "source_file": "string - absolute path",
+            "line_start": "number",
+            "line_end": "number",
+            "snippet": "string - complete HTML/CSS/JS code block",
+            "context_type": "html-structure|css-utility|react-component|vue-component|etc"
+          }
+        ]
+      }
+    }
+  ],
+
+  "_field_rules": {
+    "schema": "$schema MUST reference W3C Design Tokens format specification",
+    "semantic_tags": "structure.tag MUST use semantic HTML5 tags (header, nav, main, section, article, aside, footer)",
+    "aria": "structure.attributes MUST include ARIA attributes where applicable (role, aria-label, aria-describedby)",
+    "token_refs": "structure.layout MUST use {token.path} syntax for all spacing values",
+    "no_visual": "structure.layout MUST NOT include visual styling (colors, fonts, shadows - those belong in design-tokens)",
+    "layout_only": "structure.layout contains ONLY layout properties (display, grid, flex, position, spacing)",
+    "breakpoints": "structure.responsive MUST define breakpoint-specific overrides matching breakpoint tokens",
+    "no_repetition": "structure.responsive uses ONLY the properties that change at each breakpoint (no repetition)",
+    "recursive": "structure.children inherits same structure recursively for nested elements",
+    "component_type": "component_type MUST be 'universal' or 'specialized'",
+    "accessibility": "accessibility MUST include patterns, keyboard_navigation, focus_management, screen_reader_notes",
+    "usage_guide_universal": "usage_guide REQUIRED for universal components (buttons, inputs, forms, cards, navigation, etc.)",
+    "usage_guide_specialized": "usage_guide OPTIONAL for specialized components (can be simplified or omitted)",
+    "code_snippets": "extraction_metadata.code_snippets ONLY present in Code Import mode"
+  }
+}

.ccw/workflows/cli-tools-usage.md

@@ -0,0 +1,538 @@
+# CLI Tools Execution Specification
+
+## Table of Contents
+1. [Configuration Reference](#configuration-reference)
+2. [Tool Selection](#tool-selection)
+3. [Prompt Template](#prompt-template)
+4. [CLI Execution](#cli-execution)
+5. [Auto-Invoke Triggers](#auto-invoke-triggers)
+6. [Best Practices](#best-practices)
+
+---
+
+## Configuration Reference
+
+### Configuration File
+
+**Path**: `~/.claude/cli-tools.json`
+
+All tool availability, model selection, and routing are defined in this configuration file.
+
+### Configuration Fields
+
+| Field | Description |
+|-------|-------------|
+| `enabled` | Tool availability status |
+| `primaryModel` | Default model for the tool |
+| `secondaryModel` | Fallback model |
+| `tags` | Capability tags for routing |
+
+### Tool Types
+
+| Type | Usage | Capabilities |
+|------|-------|--------------|
+| `builtin` | `--tool gemini` | Full (analysis + write tools) |
+| `cli-wrapper` | `--tool doubao` | Full (analysis + write tools) |
+| `api-endpoint` | `--tool g25` | **Analysis only** (no file write tools) |
+
+> **Note**: `api-endpoint` tools only support analysis and code generation responses. They cannot create, modify, or delete files.
+
+---
+
+## Tool Selection
+
+### Tag-Based Routing
+
+Tools are selected based on **tags** defined in the configuration. Use tags to match task requirements to tool capabilities.
+
+#### Common Tags
+
+| Tag | Use Case |
+|-----|----------|
+| `analysis` | Code review, architecture analysis, exploration |
+| `implementation` | Feature development, bug fixes |
+| `documentation` | Doc generation, comments |
+| `testing` | Test creation, coverage analysis |
+| `refactoring` | Code restructuring |
+| `security` | Security audits, vulnerability scanning |
+
+### Selection Algorithm
+
+```
+1. Parse task intent → extract required capabilities
+2. Load cli-tools.json → get enabled tools with tags
+3. Match tags → filter tools supporting required capabilities
+4. Select tool → choose by priority (explicit > tag-match > default)
+5. Select model → use primaryModel, fallback to secondaryModel
+```
+
+### Selection Decision Tree
+
+```
+┌─ Explicit --tool specified?
+│  └─→ YES: Use specified tool (validate enabled)
+│
+└─ NO: Tag-based selection
+   ├─ Task requires tags?
+   │  └─→ Match tools with matching tags
+   │     └─→ Multiple matches? Use first enabled
+   │
+   └─ No tag match?
+      └─→ Use default tool (first enabled in config)
+```
+
+### Command Structure
+
+```bash
+# Explicit tool selection
+ccw cli -p "<PROMPT>" --tool <tool-id> --mode <analysis|write|review>
+
+# Model override
+ccw cli -p "<PROMPT>" --tool <tool-id> --model <model-id> --mode <analysis|write>
+
+# Code review (codex only)
+ccw cli -p "<PROMPT>" --tool codex --mode review
+
+# Tag-based auto-selection (future)
+ccw cli -p "<PROMPT>" --tags <tag1,tag2> --mode <analysis|write>
+```
+
+### Tool Fallback Chain
+
+When primary tool fails or is unavailable:
+1. Check `secondaryModel` for same tool
+2. Try next enabled tool with matching tags
+3. Fall back to default enabled tool
+
+---
+
+## Prompt Template
+
+### Universal Prompt Template
+
+```bash
+ccw cli -p "PURPOSE: [what] + [why] + [success criteria] + [constraints/scope]
+TASK: • [step 1: specific action] • [step 2: specific action] • [step 3: specific action]
+MODE: [analysis|write]
+CONTEXT: @[file patterns] | Memory: [session/tech/module context]
+EXPECTED: [deliverable format] + [quality criteria] + [structure requirements]
+CONSTRAINTS: [domain constraints]" --tool <tool-id> --mode <analysis|write> --rule <category-template>
+```
+
+### Intent Capture Checklist (Before CLI Execution)
+
+**⚠️ CRITICAL**: Before executing any CLI command, verify these intent dimensions:
+
+**Intent Validation Questions**:
+- [ ] Is the objective specific and measurable?
+- [ ] Are success criteria defined?
+- [ ] Is the scope clearly bounded?
+- [ ] Are constraints and limitations stated?
+- [ ] Is the expected output format clear?
+- [ ] Is the action level (read/write) explicit?
+
+### Template Structure
+
+Every command MUST include these fields:
+
+- **PURPOSE**
+  - Purpose: Goal + motivation + success
+  - Components: What + Why + Success Criteria + Constraints
+  - Bad Example: "Analyze code"
+  - Good Example: "Identify security vulnerabilities in auth module to pass compliance audit; success = all OWASP Top 10 addressed; scope = src/auth/** only"
+
+- **TASK**
+  - Purpose: Actionable steps
+  - Components: Specific verbs + targets
+  - Bad Example: "• Review code • Find issues"
+  - Good Example: "• Scan for SQL injection in query builders • Check XSS in template rendering • Verify CSRF token validation"
+
+- **MODE**
+  - Purpose: Permission level
+  - Components: analysis / write / auto
+  - Bad Example: (missing)
+  - Good Example: "analysis" or "write"
+
+- **CONTEXT**
+  - Purpose: File scope + history
+  - Components: File patterns + Memory
+  - Bad Example: "@**/*"
+  - Good Example: "@src/auth/**/*.ts @shared/utils/security.ts \| Memory: Previous auth refactoring (WFS-001)"
+
+- **EXPECTED**
+  - Purpose: Output specification
+  - Components: Format + Quality + Structure
+  - Bad Example: "Report"
+  - Good Example: "Markdown report with: severity levels (Critical/High/Medium/Low), file:line references, remediation code snippets, priority ranking"
+
+- **CONSTRAINTS**
+  - Purpose: Domain-specific constraints
+  - Components: Scope limits, special requirements, focus areas
+  - Bad Example: (missing or too vague)
+  - Good Example: "Focus on authentication | Ignore test files | No breaking changes"
+
+### CONTEXT Configuration
+
+**Format**: `CONTEXT: [file patterns] | Memory: [memory context]`
+
+#### File Patterns
+
+- **`@**/*`**: All files (default)
+- **`@src/**/*.ts`**: TypeScript in src
+- **`@../shared/**/*`**: Sibling directory (requires `--includeDirs`)
+- **`@CLAUDE.md`**: Specific file
+
+#### Memory Context
+
+Include when building on previous work:
+
+```bash
+# Cross-task reference
+Memory: Building on auth refactoring (commit abc123), implementing refresh tokens
+
+# Cross-module integration
+Memory: Integration with auth module, using shared error patterns from @shared/utils/errors.ts
+```
+
+**Memory Sources**:
+- **Related Tasks**: Previous refactoring, extensions, conflict resolution
+- **Tech Stack Patterns**: Framework conventions, security guidelines
+- **Cross-Module References**: Integration points, shared utilities, type dependencies
+
+#### Pattern Discovery Workflow
+
+For complex requirements, discover files BEFORE CLI execution:
+
+```bash
+# Step 1: Discover files (choose one method)
+# Method A: ACE semantic search (recommended)
+mcp__ace-tool__search_context(project_root_path="/path", query="React components with export")
+
+# Method B: Ripgrep pattern search
+rg "export.*Component" --files-with-matches --type ts
+
+# Step 2: Build CONTEXT
+CONTEXT: @components/Auth.tsx @types/auth.d.ts | Memory: Previous type refactoring
+
+# Step 3: Execute CLI
+ccw cli -p "..." --tool <tool-id> --mode analysis --cd src
+```
+
+### --rule Configuration
+
+**Use `--rule` option to auto-load templates**:
+
+```bash
+ccw cli -p "..." --tool gemini --mode analysis --rule analysis-review-architecture
+```
+
+### Mode Protocol References
+
+**`--rule` auto-loads Protocol based on mode**:
+- `--mode analysis` → analysis-protocol.md
+- `--mode write` → write-protocol.md
+
+**Protocol Mapping**:
+
+- **`analysis`** mode
+  - Permission: Read-only
+  - Constraint: No file create/modify/delete
+
+- **`write`** mode
+  - Permission: Create/Modify/Delete files
+  - Constraint: Full workflow execution
+
+### Template System
+
+**Available `--rule` template names**:
+
+**Universal**:
+- `universal-rigorous-style` - Precise tasks
+- `universal-creative-style` - Exploratory tasks
+
+**Analysis**:
+- `analysis-trace-code-execution` - Execution tracing
+- `analysis-diagnose-bug-root-cause` - Bug diagnosis
+- `analysis-analyze-code-patterns` - Code patterns
+- `analysis-analyze-technical-document` - Document analysis
+- `analysis-review-architecture` - Architecture review
+- `analysis-review-code-quality` - Code review
+- `analysis-analyze-performance` - Performance analysis
+- `analysis-assess-security-risks` - Security assessment
+
+**Planning**:
+- `planning-plan-architecture-design` - Architecture design
+- `planning-breakdown-task-steps` - Task breakdown
+- `planning-design-component-spec` - Component design
+- `planning-plan-migration-strategy` - Migration strategy
+
+**Development**:
+- `development-implement-feature` - Feature implementation
+- `development-refactor-codebase` - Code refactoring
+- `development-generate-tests` - Test generation
+- `development-implement-component-ui` - UI component
+- `development-debug-runtime-issues` - Runtime debugging
+
+---
+
+## CLI Execution
+
+### MODE Options
+
+- **`analysis`**
+  - Permission: Read-only
+  - Use For: Code review, architecture analysis, pattern discovery, exploration
+  - Specification: Safe for all tools
+
+- **`write`**
+  - Permission: Create/Modify/Delete
+  - Use For: Feature implementation, bug fixes, documentation, code creation, file modifications
+  - Specification: Requires explicit `--mode write`
+
+- **`review`**
+  - Permission: Read-only (code review output)
+  - Use For: Git-aware code review of uncommitted changes, branch diffs, specific commits
+  - Specification: **codex only** - uses `codex review` subcommand
+  - Tool Behavior:
+    - `codex`: Executes `codex review` for structured code review
+    - Other tools (gemini/qwen/claude): Accept mode but no operation change (treated as analysis)
+  - **Constraint**: Target flags (`--uncommitted`, `--base`, `--commit`) and prompt are mutually exclusive
+    - With prompt only: `ccw cli -p "Focus on security" --tool codex --mode review` (reviews uncommitted by default)
+    - With target flag only: `ccw cli --tool codex --mode review --commit abc123` (no prompt allowed)
+
+### Command Options
+
+- **`--tool <tool>`**
+  - Description: Tool from config (e.g., gemini, qwen, codex)
+  - Default: First enabled tool in config
+
+- **`--mode <mode>`**
+  - Description: **REQUIRED**: analysis, write, review
+  - Default: **NONE** (must specify)
+  - Note: `review` mode triggers `codex review` subcommand for codex tool only
+
+- **`--model <model>`**
+  - Description: Model override
+  - Default: Tool's primaryModel from config
+
+- **`--cd <path>`**
+  - Description: Working directory
+  - Default: current
+
+- **`--includeDirs <dirs>`**
+  - Description: Additional directories (comma-separated)
+  - Default: none
+
+- **`--resume [id]`**
+  - Description: Resume previous session
+  - Default: -
+
+- **`--rule <template>`**
+  - Description: Template name, auto-loads protocol + template appended to prompt
+  - Default: universal-rigorous-style
+  - Auto-selects protocol based on --mode
+
+### Directory Configuration
+
+#### Working Directory (`--cd`)
+
+When using `--cd`:
+- `@**/*` = Files within working directory tree only
+- CANNOT reference parent/sibling via @ alone
+- Must use `--includeDirs` for external directories
+
+#### Include Directories (`--includeDirs`)
+
+**TWO-STEP requirement for external files**:
+1. Add `--includeDirs` parameter
+2. Reference in CONTEXT with @ patterns
+
+```bash
+# Single directory
+ccw cli -p "CONTEXT: @**/* @../shared/**/*" --tool <tool-id> --mode analysis --cd src/auth --includeDirs ../shared
+
+# Multiple directories
+ccw cli -p "..." --tool <tool-id> --mode analysis --cd src/auth --includeDirs ../shared,../types,../utils
+```
+
+**Rule**: If CONTEXT contains `@../dir/**/*`, MUST include `--includeDirs ../dir`
+
+**Benefits**: Excludes unrelated directories, reduces token usage
+
+### Session Resume
+
+**When to Use**:
+- Multi-round planning (analysis → planning → implementation)
+- Multi-model collaboration (tool A → tool B on same topic)
+- Topic continuity (building on previous findings)
+
+**Usage**:
+
+```bash
+ccw cli -p "Continue analyzing" --tool <tool-id> --mode analysis --resume              # Resume last
+ccw cli -p "Fix issues found" --tool <tool-id> --mode write --resume <id>              # Resume specific
+ccw cli -p "Merge findings" --tool <tool-id> --mode analysis --resume <id1>,<id2>      # Merge multiple
+```
+
+- **`--resume`**: Last session
+- **`--resume <id>`**: Specific session
+- **`--resume <id1>,<id2>`**: Merge sessions (comma-separated)
+
+**Context Assembly** (automatic):
+```
+=== PREVIOUS CONVERSATION ===
+USER PROMPT: [Previous prompt]
+ASSISTANT RESPONSE: [Previous output]
+=== CONTINUATION ===
+[Your new prompt]
+```
+
+### Command Examples
+
+#### Task-Type Specific Templates
+
+**Analysis Task** (Security Audit):
+```bash
+ccw cli -p "PURPOSE: Identify OWASP Top 10 vulnerabilities in authentication module to pass security audit; success = all critical/high issues documented with remediation
+TASK: • Scan for injection flaws (SQL, command, LDAP) • Check authentication bypass vectors • Evaluate session management • Assess sensitive data exposure
+MODE: analysis
+CONTEXT: @src/auth/**/* @src/middleware/auth.ts | Memory: Using bcrypt for passwords, JWT for sessions
+EXPECTED: Security report with: severity matrix, file:line references, CVE mappings where applicable, remediation code snippets prioritized by risk
+CONSTRAINTS: Focus on authentication | Ignore test files
+" --tool gemini --mode analysis --rule analysis-assess-security-risks --cd src/auth
+```
+
+**Implementation Task** (New Feature):
+```bash
+ccw cli -p "PURPOSE: Implement rate limiting for API endpoints to prevent abuse; must be configurable per-endpoint; backward compatible with existing clients
+TASK: • Create rate limiter middleware with sliding window • Implement per-route configuration • Add Redis backend for distributed state • Include bypass for internal services
+MODE: write
+CONTEXT: @src/middleware/**/* @src/config/**/* | Memory: Using Express.js, Redis already configured, existing middleware pattern in auth.ts
+EXPECTED: Production-ready code with: TypeScript types, unit tests, integration test, configuration example, migration guide
+CONSTRAINTS: Follow existing middleware patterns | No breaking changes
+" --tool gemini --mode write --rule development-implement-feature
+```
+
+**Bug Fix Task**:
+```bash
+ccw cli -p "PURPOSE: Fix memory leak in WebSocket connection handler causing server OOM after 24h; root cause must be identified before any fix
+TASK: • Trace connection lifecycle from open to close • Identify event listener accumulation • Check cleanup on disconnect • Verify garbage collection eligibility
+MODE: analysis
+CONTEXT: @src/websocket/**/* @src/services/connection-manager.ts | Memory: Using ws library, ~5000 concurrent connections in production
+EXPECTED: Root cause analysis with: memory profile, leak source (file:line), fix recommendation with code, verification steps
+CONSTRAINTS: Focus on resource cleanup
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause --cd src
+```
+
+**Refactoring Task**:
+```bash
+ccw cli -p "PURPOSE: Refactor payment processing to use strategy pattern for multi-gateway support; no functional changes; all existing tests must pass
+TASK: • Extract gateway interface from current implementation • Create strategy classes for Stripe, PayPal • Implement factory for gateway selection • Migrate existing code to use strategies
+MODE: write
+CONTEXT: @src/payments/**/* @src/types/payment.ts | Memory: Currently only Stripe, adding PayPal next sprint, must support future gateways
+EXPECTED: Refactored code with: strategy interface, concrete implementations, factory class, updated tests, migration checklist
+CONSTRAINTS: Preserve all existing behavior | Tests must pass
+" --tool gemini --mode write --rule development-refactor-codebase
+```
+
+**Code Review Task** (codex review mode):
+```bash
+# Option 1: Custom prompt (reviews uncommitted changes by default)
+ccw cli -p "Focus on security vulnerabilities and error handling" --tool codex --mode review
+
+# Option 2: Target flag only (no prompt allowed with target flags)
+ccw cli --tool codex --mode review --uncommitted
+ccw cli --tool codex --mode review --base main
+ccw cli --tool codex --mode review --commit abc123
+```
+
+> **Note**: `--mode review` only triggers special behavior for `codex` tool. Target flags (`--uncommitted`, `--base`, `--commit`) and prompt are **mutually exclusive** - use one or the other, not both.
+
+---
+
+### Permission Framework
+
+**Single-Use Authorization**: Each execution requires explicit user instruction. Previous authorization does NOT carry over.
+
+**Mode Hierarchy**:
+- `analysis`: Read-only, safe for auto-execution
+- `write`: Create/Modify/Delete files, full operations - requires explicit `--mode write`
+- `review`: Git-aware code review (codex only), read-only output - requires explicit `--mode review`
+- **Exception**: User provides clear instructions like "modify", "create", "implement"
+
+---
+
+## Auto-Invoke Triggers
+
+**Proactive CLI invocation** - Auto-invoke `ccw cli` when encountering these scenarios:
+
+| Trigger Condition | Suggested Rule | When to Use |
+|-------------------|----------------|-------------|
+| **Self-repair fails** | `analysis-diagnose-bug-root-cause` | After 1+ failed fix attempts |
+| **Ambiguous requirements** | `planning-breakdown-task-steps` | Task description lacks clarity |
+| **Architecture decisions** | `planning-plan-architecture-design` | Complex feature needs design |
+| **Pattern uncertainty** | `analysis-analyze-code-patterns` | Unsure of existing conventions |
+| **Critical code paths** | `analysis-assess-security-risks` | Security/performance sensitive |
+
+### Execution Principles
+
+- **Default mode**: `--mode analysis` (read-only, safe for auto-execution)
+- **No confirmation needed**: Invoke proactively when triggers match
+- **Wait for results**: Complete analysis before next action
+- **Tool selection**: Use context-appropriate tool or fallback chain (`gemini` → `qwen` → `codex`)
+- **Rule flexibility**: Suggested rules are guidelines, not requirements - choose the most appropriate template for the situation
+
+### Example: Bug Fix with Auto-Invoke
+
+```bash
+# After 1+ failed fix attempts, auto-invoke root cause analysis
+ccw cli -p "PURPOSE: Identify root cause of [bug description]; success = actionable fix strategy
+TASK: • Trace execution flow • Identify failure point • Analyze state at failure • Determine fix approach
+MODE: analysis
+CONTEXT: @src/module/**/* | Memory: Previous fix attempts failed at [location]
+EXPECTED: Root cause analysis with: failure mechanism, stack trace interpretation, fix recommendation with code
+CONSTRAINTS: Focus on [specific area]
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+---
+
+## Best Practices
+
+### Core Principles
+
+- **Configuration-driven** - All tool selection from `cli-tools.json`
+- **Tag-based routing** - Match task requirements to tool capabilities
+- **Use tools early and often** - Tools are faster and more thorough
+- **Unified CLI** - Always use `ccw cli -p` for consistent parameter handling
+- **Default mode is analysis** - Omit `--mode` for read-only operations, explicitly use `--mode write` for file modifications
+- **Use `--rule` for templates** - Auto-loads protocol + template appended to prompt
+- **Write protection** - Require EXPLICIT `--mode write` for file operations
+
+### Workflow Principles
+
+- **Use CCW unified interface** for all executions
+- **Always include template** - Use `--rule <template-name>` to load templates
+- **Be specific** - Clear PURPOSE, TASK, EXPECTED fields
+- **Include constraints** - File patterns, scope in CONSTRAINTS
+- **Leverage memory context** when building on previous work
+- **Discover patterns first** - Use rg/MCP before CLI execution
+- **Default to full context** - Use `@**/*` unless specific files needed
+
+### Planning Checklist
+
+- [ ] **Purpose defined** - Clear goal and intent
+- [ ] **Mode selected** - `--mode analysis|write|review`
+- [ ] **Context gathered** - File references + memory (default `@**/*`)
+- [ ] **Directory navigation** - `--cd` and/or `--includeDirs`
+- [ ] **Tool selected** - Explicit `--tool` or tag-based auto-selection
+- [ ] **Rule template** - `--rule <template-name>` loads template
+- [ ] **Constraints** - Domain constraints in CONSTRAINTS field
+
+### Execution Workflow
+
+1. **Load configuration** - Read `cli-tools.json` for available tools
+2. **Match by tags** - Select tool based on task requirements
+3. **Validate enabled** - Ensure selected tool is enabled
+4. **Execute with mode** - Always specify `--mode analysis|write|review`
+5. **Fallback gracefully** - Use secondary model or next matching tool on failure