claude-symphony 0.2.6 → 0.2.7

package/dist/cli/index.js

@@ -129,6 +129,16 @@ async function readFile(filePath) {
     return null;
   }
 }
+async function writeFile(filePath, content) {
+  try {
+    await ensureDirAsync(path.dirname(filePath));
+    await fs.writeFile(filePath, content, "utf8");
+    return true;
+  } catch (error) {
+    console.error(`Failed to write file ${filePath}:`, error);
+    return false;
+  }
+}
 async function readJson(filePath) {
   try {
     const content = await fs.readFile(filePath, "utf8");
@@ -1458,13 +1468,37 @@ async function gotoStage(projectRoot, targetStage, options = {}) {
   console.log(`  To:   ${targetStage} (${getStageName(targetStage)})`);
   const historyPath = path4.join(projectRoot, "state", "loopback_history.json");
   let history = await readJson(historyPath) ?? [];
+  const timestamp = getTimestamp();
   history.push({
     from: currentStage,
     to: targetStage,
-    timestamp: getTimestamp()
+    timestamp,
+    reason: options.reason
   });
   await ensureDirAsync(path4.join(projectRoot, "state"));
   await writeJson(historyPath, history);
+  const handoffPath = path4.join(projectRoot, "stages", currentStage, "HANDOFF.md");
+  if (existsSync2(handoffPath)) {
+    const handoffContent = await readFile(handoffPath);
+    if (handoffContent) {
+      const loopbackRecord = `
+
+## Loop-Back Record
+
+| Field | Value |
+|-------|-------|
+| **From** | ${currentStage} |
+| **To** | ${targetStage} |
+| **Time** | ${timestamp} |
+| **Reason** | ${options.reason ?? "(not specified)"} |
+
+---
+`;
+      await writeFile(handoffPath, handoffContent + loopbackRecord);
+      console.log("\n[HANDOFF Updated]");
+      logSuccess(`Loop-back recorded in stages/${currentStage}/HANDOFF.md`);
+    }
+  }
   await runStage(projectRoot, targetStage);
   return true;
 }
@@ -3222,7 +3256,7 @@ program.command("next").description("Transition to next stage (or next sprint)")
   });
   process.exit(success ? 0 : 1);
 });
-program.command("goto [stage-id]").description("Jump to a previous stage (loop-back)").option("--list", "List available stages").option("--history", "Show loop-back history").action(async (stageId, options) => {
+program.command("goto [stage-id]").description("Jump to a previous stage (loop-back)").option("--list", "List available stages").option("--history", "Show loop-back history").option("-r, --reason <text>", "Record reason for stage transition").action(async (stageId, options) => {
   const projectRoot = process.cwd();
   const success = await gotoStage(projectRoot, stageId, options);
   process.exit(success ? 0 : 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-symphony",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Multi-AI Orchestration Framework - Create new projects with 10-stage development workflow",
   "type": "module",
   "bin": {

package/template/.claude/commands/brainstorm.md

@@ -2,6 +2,18 @@
 
 Start the 01-brainstorm stage directly.
 
+## CRITICAL: Parallel Execution Required
+
+> **This stage MUST use Gemini + ClaudeCode parallel execution.**
+>
+> Gemini CLI provides creative, divergent thinking while ClaudeCode provides technical review.
+> Skipping Gemini CLI significantly degrades idea quality and creativity.
+
+**Mandatory Steps:**
+1. Call `/gemini` with ideation prompt (Primary - Creative Ideas)
+2. ClaudeCode technical review (Secondary - Technical Validation)
+3. Synthesize both outputs into final `ideas.md`
+
 ## Usage
 ```
 /brainstorm [topic]
@@ -12,21 +24,87 @@ Start the 01-brainstorm stage directly.
 | Item | Value |
 |------|-------|
 | Stage | 01-brainstorm |
-| AI Model | Gemini + ClaudeCode |
+| AI Model | **Gemini + ClaudeCode (Parallel)** |
 | Execution Mode | YOLO (Container) |
 | Checkpoint | Optional |
 
+## Parallel Execution Protocol
+
+```
+┌─────────────────────────────────────────────────┐
+│              01-brainstorm Stage                │
+├─────────────────────────────────────────────────┤
+│                                                 │
+│   ┌─────────────┐     ┌─────────────┐          │
+│   │   Gemini    │     │ ClaudeCode  │          │
+│   │  (Primary)  │     │ (Secondary) │          │
+│   │  Creative   │     │  Technical  │          │
+│   └──────┬──────┘     └──────┬──────┘          │
+│          │                   │                  │
+│          │   Parallel        │                  │
+│          │   Execution       │                  │
+│          ▼                   ▼                  │
+│   output_gemini.md    output_claudecode.md     │
+│          │                   │                  │
+│          └─────────┬─────────┘                  │
+│                    ▼                            │
+│          ┌─────────────────┐                   │
+│          │   Synthesizer   │                   │
+│          │  (ClaudeCode)   │                   │
+│          └────────┬────────┘                   │
+│                   ▼                             │
+│              ideas.md                           │
+└─────────────────────────────────────────────────┘
+```
+
+## Execution Steps
+
+### Step 1: Gemini CLI Call (Primary - Creative Ideas)
+
+**MUST execute Gemini CLI for creative ideation:**
+
+```bash
+/gemini "Read stages/01-brainstorm/prompts/ideation.md and generate creative ideas for: $TOPIC"
+```
+
+- **Input**: `stages/01-brainstorm/prompts/ideation.md`
+- **Output**: `stages/01-brainstorm/outputs/output_gemini.md`
+- **Focus**: Divergent thinking, unconstrained exploration, novel approaches
+
+### Step 2: ClaudeCode Technical Review (Secondary)
+
+After Gemini output is generated, ClaudeCode performs technical review:
+
+- **Input**: Gemini output + project context
+- **Output**: `stages/01-brainstorm/outputs/output_claudecode.md`
+- **Focus**: Technical feasibility, implementation complexity, risk assessment
+
+### Step 3: Synthesis (ClaudeCode as Synthesizer)
+
+Combine both outputs into final deliverables:
+
+```bash
+/synthesize
+```
+
+- **Inputs**: `output_gemini.md` + `output_claudecode.md`
+- **Output**: `stages/01-brainstorm/outputs/ideas.md`
+- **Criteria**:
+  - Prioritize ideas both models agree on (HIGH CONFIDENCE)
+  - Evaluate unique contributions from each
+  - Filter low-quality or infeasible ideas
+
 ## Actions
 
 1. **Prerequisite Check**
    - Project initialization status (progress.json)
 
 2. **Stage Start**
-   - Gemini CLI call (creative ideas)
+   - Gemini CLI call (creative ideas) - **REQUIRED**
    - ClaudeCode parallel execution (technical review)
 
 3. **Output Generation**
-   - ideas.md - Brainstorming ideas
+   - ideas.md - Synthesized brainstorming ideas
    - decisions.md - Key decisions
 
 ## Execution
@@ -40,28 +118,45 @@ scripts/run-stage.sh 01-brainstorm "$ARGUMENTS"
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🧠 Stage 01: Brainstorm
+ Stage 01: Brainstorm
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 AI: Gemini + ClaudeCode (parallel)
 Mode: YOLO (Container)
 
 Topic: $ARGUMENTS
 
-[Gemini] Generating creative ideas...
-[ClaudeCode] Technical review in progress...
+[Step 1] Gemini CLI - Generating creative ideas...
+         Output: outputs/output_gemini.md
+
+[Step 2] ClaudeCode - Technical review in progress...
+         Output: outputs/output_claudecode.md
+
+[Step 3] Synthesizing outputs...
+         Final: outputs/ideas.md
 
 After completion: /next or /research
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
+## Output Files
+
+| File | Description |
+|------|-------------|
+| `outputs/output_gemini.md` | Gemini creative ideas |
+| `outputs/output_claudecode.md` | ClaudeCode technical review |
+| `outputs/ideas.md` | Final synthesized ideas |
+| `outputs/decisions.md` | Key decisions |
+
 ## Related Commands
 
 - `/run-stage 01` - Start after prerequisite check
 - `/next` - Next stage (02-research)
 - `/gemini` - Direct Gemini CLI call
+- `/synthesize` - Consolidate parallel outputs
 
 ## Tips
 
 - YOLO mode: Failure is okay, creativity first
 - Freely explore multiple ideas
+- **Always call Gemini CLI first** for maximum creativity
 - Record final selections in decisions.md

package/template/.claude/commands/goto.md

@@ -0,0 +1,103 @@
+# /goto - Stage Navigation (Loop-back)
+
+Jump to a specific stage in the pipeline.
+
+## Usage
+
+```
+/goto <stage-id>     # Move to specific stage
+/goto --list         # Show available stages
+/goto --history      # Show loop-back history
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `--list` | Display all available stages with status |
+| `--history` | Show history of previous loop-backs |
+| `--reason <text>` | Record reason for stage transition |
+
+## Examples
+
+### Basic Navigation
+
+```bash
+# Go to planning stage
+/goto 03-planning
+
+# Return to brainstorming for new ideas
+/goto 01-brainstorm
+
+# Jump to QA for bug fixes
+/goto 08-qa
+```
+
+### With Reason (Recommended)
+
+```bash
+# Document why you're transitioning
+/goto 03-planning --reason "architecture redesign needed"
+/goto 08-qa --reason "critical bug discovered in authentication"
+```
+
+### View Options
+
+```bash
+# List all stages
+/goto --list
+
+# Check previous transitions
+/goto --history
+```
+
+## Stage List
+
+| Stage ID | Name |
+|----------|------|
+| `01-brainstorm` | Brainstorming |
+| `02-research` | Research |
+| `03-planning` | Planning |
+| `04-ui-ux` | UI/UX Planning |
+| `05-task-management` | Task Management |
+| `06-implementation` | Implementation |
+| `07-refactoring` | Refactoring |
+| `08-qa` | QA |
+| `09-testing` | Testing & E2E |
+| `10-deployment` | CI/CD & Deployment |
+
+## Output Example
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Stage Loop-back
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  From: 06-implementation (Implementation)
+  To:   03-planning (Planning)
+
+[HANDOFF Updated]
+✓ Loop-back recorded in stages/06-implementation/HANDOFF.md
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🚀 Stage Execution: 03-planning
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Execution Script
+
+```bash
+claude-symphony goto <stage-id> [options]
+```
+
+## Notes
+
+- Loop-back history is stored in `state/loopback_history.json`
+- Current stage's HANDOFF.md is updated with transition record
+- Use `/goto --list` to see current stage status before navigating
+
+## Related Commands
+
+- `/next` - Proceed to next sequential stage
+- `/status` - Check current pipeline status
+- `/stages` - View all stages with status
+- `/handoff` - Generate HANDOFF.md before transitioning

package/template/.claude/commands/planning.md

@@ -2,6 +2,18 @@
 
 Start the 03-planning stage directly.
 
+## CRITICAL: Parallel Execution Required
+
+> **This stage MUST use Gemini + ClaudeCode parallel execution.**
+>
+> Gemini provides strategic architectural vision while ClaudeCode provides detailed technical planning.
+> Both perspectives are essential for robust architecture design.
+
+**Mandatory Steps:**
+1. Call `/gemini` with architecture prompt (Primary - Strategic Vision)
+2. ClaudeCode detailed planning (Secondary - Technical Specification)
+3. Synthesize both outputs into final architecture documents
+
 ## Usage
 ```
 /planning
@@ -12,10 +24,72 @@ Start the 03-planning stage directly.
 | Item | Value |
 |------|-------|
 | Stage | 03-planning |
-| AI Model | Gemini |
+| AI Model | **Gemini + ClaudeCode (Parallel)** |
 | Execution Mode | Plan Mode |
 | Checkpoint | Optional |
 
+## Parallel Execution Protocol
+
+```
+┌─────────────────────────────────────────────────┐
+│              03-planning Stage                  │
+├─────────────────────────────────────────────────┤
+│                                                 │
+│   ┌─────────────┐     ┌─────────────┐          │
+│   │   Gemini    │     │ ClaudeCode  │          │
+│   │  (Primary)  │     │ (Secondary) │          │
+│   │  Strategic  │     │  Technical  │          │
+│   └──────┬──────┘     └──────┬──────┘          │
+│          │                   │                  │
+│          │   Parallel        │                  │
+│          │   Execution       │                  │
+│          ▼                   ▼                  │
+│   output_gemini.md    output_claudecode.md     │
+│          │                   │                  │
+│          └─────────┬─────────┘                  │
+│                    ▼                            │
+│          ┌─────────────────┐                   │
+│          │   Synthesizer   │                   │
+│          │  (ClaudeCode)   │                   │
+│          └────────┬────────┘                   │
+│                   ▼                             │
+│         PRD.md + architecture.md               │
+└─────────────────────────────────────────────────┘
+```
+
+## Execution Steps
+
+### Step 1: Gemini CLI Call (Primary - Strategic Vision)
+
+**MUST execute Gemini CLI for strategic planning:**
+
+```bash
+/gemini "Read stages/03-planning/prompts/architecture.md and research output to create strategic architecture vision"
+```
+
+- **Input**: `stages/02-research/outputs/research.md`, `tech-stack.md`
+- **Output**: `stages/03-planning/outputs/output_gemini.md`
+- **Focus**: High-level architecture, strategic decisions, scalability vision
+
+### Step 2: ClaudeCode Technical Planning (Secondary)
+
+After Gemini output is generated, ClaudeCode performs detailed planning:
+
+- **Input**: Gemini output + research results
+- **Output**: `stages/03-planning/outputs/output_claudecode.md`
+- **Focus**: Technical specifications, implementation details, risk mitigation
+
+### Step 3: Synthesis (ClaudeCode as Synthesizer)
+
+Combine both outputs into final deliverables:
+
+```bash
+/synthesize
+```
+
+- **Inputs**: `output_gemini.md` + `output_claudecode.md`
+- **Output**: `stages/03-planning/outputs/PRD.md`, `architecture.md`
+
 ## Actions
 
 1. **Prerequisite Check**
@@ -23,9 +97,10 @@ Start the 03-planning stage directly.
    - research.md, tech-stack.md exist
 
 2. **Execute Planning**
+   - Gemini CLI call (strategic vision) - **REQUIRED**
+   - ClaudeCode parallel execution (technical details)
    - PRD (Product Requirements Document) writing
    - Architecture design
-   - Technical specification
 
 3. **Output Generation**
    - PRD.md - Product Requirements Document
@@ -44,8 +119,12 @@ scripts/run-stage.sh 03-planning "$ARGUMENTS"
 
 ## Output Files
 
-- `stages/03-planning/outputs/PRD.md`
-- `stages/03-planning/outputs/architecture.md`
+| File | Description |
+|------|-------------|
+| `outputs/output_gemini.md` | Gemini strategic vision |
+| `outputs/output_claudecode.md` | ClaudeCode technical spec |
+| `outputs/PRD.md` | Product Requirements Document |
+| `outputs/architecture.md` | Architecture design |
 
 ## Related Commands
 
@@ -53,6 +132,7 @@ scripts/run-stage.sh 03-planning "$ARGUMENTS"
 - `/next` - Next stage (04-ui-ux)
 - `/research` - Previous stage
 - `/gemini` - Direct Gemini CLI call
+- `/synthesize` - Consolidate parallel outputs
 
 ## PRD Structure
 

package/template/.claude/commands/refactor.md

@@ -2,6 +2,18 @@
 
 Start the 07-refactoring stage directly.
 
+## CRITICAL: Parallel Execution Required
+
+> **This stage MUST use Codex + ClaudeCode parallel execution.**
+>
+> Codex provides deep code analysis and optimization suggestions while ClaudeCode provides implementation and verification.
+> Both perspectives ensure thorough refactoring with proper validation.
+
+**Mandatory Steps:**
+1. Call `/codex` with analysis prompt (Primary - Deep Analysis)
+2. ClaudeCode implementation review (Secondary - Apply & Verify)
+3. Synthesize both outputs into final refactoring report
+
 ## Usage
 ```
 /refactor [focus-area]
@@ -12,10 +24,74 @@ Start the 07-refactoring stage directly.
 | Item | Value |
 |------|-------|
 | Stage | 07-refactoring |
-| AI Model | Codex → ClaudeCode |
+| AI Model | **Codex + ClaudeCode (Parallel)** |
 | Execution Mode | Deep Dive |
 | Checkpoint | **Required** |
 
+## Parallel Execution Protocol
+
+```
+┌─────────────────────────────────────────────────┐
+│            07-refactoring Stage                 │
+├─────────────────────────────────────────────────┤
+│                                                 │
+│   ┌─────────────┐     ┌─────────────┐          │
+│   │    Codex    │     │ ClaudeCode  │          │
+│   │  (Primary)  │     │ (Secondary) │          │
+│   │    Deep     │     │   Apply &   │          │
+│   │  Analysis   │     │   Verify    │          │
+│   └──────┬──────┘     └──────┬──────┘          │
+│          │                   │                  │
+│          │   Parallel        │                  │
+│          │   Execution       │                  │
+│          ▼                   ▼                  │
+│   output_codex.md     output_claudecode.md     │
+│          │                   │                  │
+│          └─────────┬─────────┘                  │
+│                    ▼                            │
+│          ┌─────────────────┐                   │
+│          │   Synthesizer   │                   │
+│          │  (ClaudeCode)   │                   │
+│          └────────┬────────┘                   │
+│                   ▼                             │
+│     refactoring-report.md + improved src/      │
+└─────────────────────────────────────────────────┘
+```
+
+## Execution Steps
+
+### Step 1: Codex CLI Call (Primary - Deep Analysis)
+
+**MUST execute Codex CLI for deep code analysis:**
+
+```bash
+/codex "Analyze stages/06-implementation/outputs/src/ for refactoring opportunities: $FOCUS_AREA"
+```
+
+- **Input**: `stages/06-implementation/outputs/src/`, `tests/`
+- **Output**: `stages/07-refactoring/outputs/output_codex.md`
+- **Focus**: Code smells, optimization opportunities, architectural improvements
+
+### Step 2: ClaudeCode Implementation Review (Secondary)
+
+After Codex output is generated, ClaudeCode performs implementation review:
+
+- **Input**: Codex analysis + source code
+- **Output**: `stages/07-refactoring/outputs/output_claudecode.md`
+- **Focus**: Implementation feasibility, test impact, backward compatibility
+
+### Step 3: Synthesis & Apply (ClaudeCode as Synthesizer)
+
+Combine both outputs and apply refactoring:
+
+```bash
+/synthesize
+```
+
+- **Inputs**: `output_codex.md` + `output_claudecode.md`
+- **Output**: `refactoring-report.md` + improved `src/`
+- **Verification**: Run tests after each refactoring
+
 ## Actions
 
 1. **Prerequisite Check**
@@ -24,8 +100,9 @@ Start the 07-refactoring stage directly.
    - 06 checkpoint exists
 
 2. **Execute Refactoring**
-   - Codex: Code analysis and improvement suggestions
-   - ClaudeCode: Apply refactoring
+   - Codex CLI call (deep analysis) - **REQUIRED**
+   - ClaudeCode parallel execution (apply & verify)
+   - Apply refactoring changes
 
 3. **Output Generation**
    - (Improved) src/
@@ -37,18 +114,6 @@ Start the 07-refactoring stage directly.
 scripts/run-stage.sh 07-refactoring "$ARGUMENTS"
 ```
 
-## Workflow
-
-```
-Codex (Analysis)
-    ↓
-Identify Improvements
-    ↓
-ClaudeCode (Apply)
-    ↓
-Test Verification
-```
-
 ## Input Files
 
 - `stages/06-implementation/outputs/src/`
@@ -56,8 +121,12 @@ Test Verification
 
 ## Output Files
 
-- (Modified) `src/`
-- `stages/07-refactoring/outputs/refactoring-report.md`
+| File | Description |
+|------|-------------|
+| `outputs/output_codex.md` | Codex deep analysis |
+| `outputs/output_claudecode.md` | ClaudeCode review |
+| `outputs/refactoring-report.md` | Final refactoring report |
+| (Modified) `src/` | Improved source code |
 
 ## Checkpoint Required!
 
@@ -87,9 +156,11 @@ Test Verification
 - `/codex` - Direct Codex CLI call
 - `/checkpoint` - Create checkpoint
 - `/restore` - Rollback
+- `/synthesize` - Consolidate parallel outputs
 
 ## Tips
 
 - Always checkpoint before refactoring
+- **Always call Codex CLI first** for thorough analysis
 - Incremental improvements in small units
 - Commit after test pass verification

package/template/.claude/commands/test.md

@@ -2,6 +2,18 @@
 
 Start the 09-testing stage directly.
 
+## CRITICAL: Parallel Execution Required
+
+> **This stage MUST use Codex + ClaudeCode parallel execution.**
+>
+> Codex provides comprehensive test generation while ClaudeCode provides E2E testing with Playwright.
+> Both perspectives ensure thorough test coverage across all test types.
+
+**Mandatory Steps:**
+1. Call `/codex` with testing prompt (Primary - Test Generation)
+2. ClaudeCode E2E testing (Secondary - Playwright Integration)
+3. Synthesize both outputs into final test results
+
 ## Usage
 ```
 /test [test-type]
@@ -12,10 +24,73 @@ Start the 09-testing stage directly.
 | Item | Value |
 |------|-------|
 | Stage | 09-testing |
-| AI Model | Codex |
+| AI Model | **Codex + ClaudeCode (Parallel)** |
 | Execution Mode | Sandbox + Playwright MCP |
 | Checkpoint | Optional |
 
+## Parallel Execution Protocol
+
+```
+┌─────────────────────────────────────────────────┐
+│              09-testing Stage                   │
+├─────────────────────────────────────────────────┤
+│                                                 │
+│   ┌─────────────┐     ┌─────────────┐          │
+│   │    Codex    │     │ ClaudeCode  │          │
+│   │  (Primary)  │     │ (Secondary) │          │
+│   │    Test     │     │    E2E &    │          │
+│   │ Generation  │     │ Playwright  │          │
+│   └──────┬──────┘     └──────┬──────┘          │
+│          │                   │                  │
+│          │   Parallel        │                  │
+│          │   Execution       │                  │
+│          ▼                   ▼                  │
+│   output_codex.md     output_claudecode.md     │
+│          │                   │                  │
+│          └─────────┬─────────┘                  │
+│                    ▼                            │
+│          ┌─────────────────┐                   │
+│          │   Synthesizer   │                   │
+│          │  (ClaudeCode)   │                   │
+│          └────────┬────────┘                   │
+│                   ▼                             │
+│    test-results.md + coverage-report.html      │
+└─────────────────────────────────────────────────┘
+```
+
+## Execution Steps
+
+### Step 1: Codex CLI Call (Primary - Test Generation)
+
+**MUST execute Codex CLI for comprehensive test generation:**
+
+```bash
+/codex "Analyze stages/06-implementation/outputs/src/ and generate comprehensive tests: $TEST_TYPE"
+```
+
+- **Input**: `stages/06-implementation/outputs/src/`, `tests/`, `qa-report.md`
+- **Output**: `stages/09-testing/outputs/output_codex.md`
+- **Focus**: Unit tests, integration tests, edge cases, regression tests
+
+### Step 2: ClaudeCode E2E Testing (Secondary)
+
+After Codex output is generated, ClaudeCode performs E2E testing:
+
+- **Input**: Codex analysis + application
+- **Output**: `stages/09-testing/outputs/output_claudecode.md`
+- **Focus**: E2E flows, Playwright automation, visual testing
+
+### Step 3: Synthesis (ClaudeCode as Synthesizer)
+
+Combine both outputs into final test suite:
+
+```bash
+/synthesize
+```
+
+- **Inputs**: `output_codex.md` + `output_claudecode.md`
+- **Output**: `test-results.md`, `e2e-results/`, `coverage/`
+
 ## Actions
 
 1. **Prerequisite Check**
@@ -23,8 +98,9 @@ Start the 09-testing stage directly.
    - qa-report.md exists
 
 2. **Execute Testing**
+   - Codex CLI call (test generation) - **REQUIRED**
+   - ClaudeCode parallel execution (E2E with Playwright)
    - Integration tests
-   - E2E tests (Playwright)
    - Regression tests
 
 3. **Output Generation**
@@ -45,9 +121,13 @@ scripts/run-stage.sh 09-testing "$ARGUMENTS"
 
 ## Output Files
 
-- `stages/09-testing/outputs/test-results.md`
-- `stages/09-testing/outputs/e2e-results/`
-- `stages/09-testing/outputs/coverage/`
+| File | Description |
+|------|-------------|
+| `outputs/output_codex.md` | Codex test generation |
+| `outputs/output_claudecode.md` | ClaudeCode E2E results |
+| `outputs/test-results.md` | Final test results |
+| `outputs/e2e-results/` | E2E test results |
+| `outputs/coverage/` | Coverage reports |
 
 ## Test Types
 
@@ -77,6 +157,8 @@ mcp__playwright__browser_fill_form
 - `/next` - Next stage (10-deployment)
 - `/qa` - Previous stage
 - `/deploy` - Start deployment directly
+- `/codex` - Direct Codex CLI call
+- `/synthesize` - Consolidate parallel outputs
 
 ## Coverage Targets
 
@@ -88,6 +170,7 @@ mcp__playwright__browser_fill_form
 
 ## Tips
 
+- **Always call Codex CLI first** for comprehensive test generation
 - E2E focuses on critical flows
 - Auto-save screenshots on failure
 - Run headless mode in CI

package/template/.claude/commands/ui-ux.md

@@ -2,6 +2,18 @@
 
 Start the 04-ui-ux stage directly.
 
+## CRITICAL: Parallel Execution Required
+
+> **This stage MUST use Gemini + ClaudeCode parallel execution.**
+>
+> Gemini provides creative design exploration while ClaudeCode provides technical component specification.
+> Both perspectives ensure designs are both innovative and implementable.
+
+**Mandatory Steps:**
+1. Call `/gemini` with design prompt (Primary - Creative Design)
+2. ClaudeCode component specification (Secondary - Technical Spec)
+3. Synthesize both outputs into final design documents
+
 ## Usage
 ```
 /ui-ux
@@ -12,10 +24,73 @@ Start the 04-ui-ux stage directly.
 | Item | Value |
 |------|-------|
 | Stage | 04-ui-ux |
-| AI Model | Gemini |
+| AI Model | **Gemini + ClaudeCode (Parallel)** |
 | Execution Mode | Plan Mode |
 | Checkpoint | Optional |
 
+## Parallel Execution Protocol
+
+```
+┌─────────────────────────────────────────────────┐
+│               04-ui-ux Stage                    │
+├─────────────────────────────────────────────────┤
+│                                                 │
+│   ┌─────────────┐     ┌─────────────┐          │
+│   │   Gemini    │     │ ClaudeCode  │          │
+│   │  (Primary)  │     │ (Secondary) │          │
+│   │  Creative   │     │  Technical  │          │
+│   │   Design    │     │    Spec     │          │
+│   └──────┬──────┘     └──────┬──────┘          │
+│          │                   │                  │
+│          │   Parallel        │                  │
+│          │   Execution       │                  │
+│          ▼                   ▼                  │
+│   output_gemini.md    output_claudecode.md     │
+│          │                   │                  │
+│          └─────────┬─────────┘                  │
+│                    ▼                            │
+│          ┌─────────────────┐                   │
+│          │   Synthesizer   │                   │
+│          │  (ClaudeCode)   │                   │
+│          └────────┬────────┘                   │
+│                   ▼                             │
+│   wireframes/ + component-spec.md              │
+└─────────────────────────────────────────────────┘
+```
+
+## Execution Steps
+
+### Step 1: Gemini CLI Call (Primary - Creative Design)
+
+**MUST execute Gemini CLI for creative design exploration:**
+
+```bash
+/gemini "Read stages/04-ui-ux/prompts/design.md and PRD to create innovative UI/UX designs"
+```
+
+- **Input**: `stages/03-planning/outputs/PRD.md`, `architecture.md`
+- **Output**: `stages/04-ui-ux/outputs/output_gemini.md`
+- **Focus**: Creative layouts, user flow innovation, visual concepts
+
+### Step 2: ClaudeCode Technical Specification (Secondary)
+
+After Gemini output is generated, ClaudeCode performs technical specification:
+
+- **Input**: Gemini output + PRD + architecture
+- **Output**: `stages/04-ui-ux/outputs/output_claudecode.md`
+- **Focus**: Component structure, state management, implementation feasibility
+
+### Step 3: Synthesis (ClaudeCode as Synthesizer)
+
+Combine both outputs into final deliverables:
+
+```bash
+/synthesize
+```
+
+- **Inputs**: `output_gemini.md` + `output_claudecode.md`
+- **Output**: `wireframes/`, `component-spec.md`, `design-system.md`
+
 ## Actions
 
 1. **Prerequisite Check**
@@ -23,6 +98,8 @@ Start the 04-ui-ux stage directly.
    - PRD.md exists
 
 2. **UI/UX Design**
+   - Gemini CLI call (creative design) - **REQUIRED**
+   - ClaudeCode parallel execution (technical spec)
    - Wireframe design
    - Component specification
    - Design system
@@ -45,15 +122,21 @@ scripts/run-stage.sh 04-ui-ux "$ARGUMENTS"
 
 ## Output Files
 
-- `stages/04-ui-ux/outputs/wireframes/`
-- `stages/04-ui-ux/outputs/component-spec.md`
-- `stages/04-ui-ux/outputs/design-system.md`
+| File | Description |
+|------|-------------|
+| `outputs/output_gemini.md` | Gemini creative designs |
+| `outputs/output_claudecode.md` | ClaudeCode technical spec |
+| `outputs/wireframes/` | Wireframe files |
+| `outputs/component-spec.md` | Component specification |
+| `outputs/design-system.md` | Design system |
 
 ## Related Commands
 
 - `/run-stage 04` - Start after prerequisite check
 - `/next` - Next stage (05-task-management)
 - `/planning` - Previous stage
+- `/gemini` - Direct Gemini CLI call
+- `/synthesize` - Consolidate parallel outputs
 
 ## Tool Utilization
 

package/template/.claude/skills/stage-routing/README.md

@@ -0,0 +1,162 @@
+# Stage Routing Skill
+
+Automatically analyze user prompts and recommend appropriate pipeline stages.
+
+## Overview
+
+This skill detects keywords and patterns in user requests to determine if a different stage would be more appropriate for the requested work.
+
+## Auto-Trigger Conditions
+
+The skill activates when user prompts contain:
+
+1. **Work type indicators**
+   - Feature requests → 06-implementation
+   - Bug reports → 08-qa
+   - Test requests → 09-testing
+   - Design changes → 04-ui-ux
+
+2. **Action keywords**
+   - "구현해", "만들어" → Implementation
+   - "버그", "오류", "수정" → QA/Debugging
+   - "테스트", "검증" → Testing
+   - "설계", "아키텍처" → Planning
+
+3. **Scale indicators**
+   - Architecture-level changes → 03-planning
+   - Multi-module changes → Consider planning first
+
+## Configuration
+
+Located at: `config/stage_routing.jsonc`
+
+### Key Settings
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `confidence_threshold` | 0.6 | Minimum confidence for recommendation |
+| `auto_transition` | false | Auto-transition without confirmation |
+| `require_user_confirmation` | true | Always ask before transitioning |
+| `min_keyword_matches` | 2 | Minimum keyword matches required |
+
+## Detection Logic
+
+### 1. Keyword Matching
+
+Each stage has defined keywords that indicate relevance:
+
+```
+06-implementation: ["구현", "개발", "코드", "기능", "만들어"]
+08-qa: ["버그", "오류", "수정", "fix", "에러"]
+09-testing: ["테스트", "coverage", "검증"]
+```
+
+### 2. Confidence Calculation
+
+```
+confidence = (matched_keywords + trigger_matches) / total_indicators
+```
+
+### 3. Scale Detection
+
+| Scale | Criteria | Action |
+|-------|----------|--------|
+| Small | ≤3 files | Stay in current stage |
+| Medium | 4-10 files | Consider related stage |
+| Large | >10 files or architecture keywords | Recommend 03-planning |
+
+## Output Format (Simplified)
+
+**Important**: Internal logic (keywords, confidence scores, intents) is NOT shown to users.
+Only display a simple, friendly question.
+
+### When a different stage is recommended:
+
+```
+🔄 08 QA 스테이지로 이동해서 버그를 수정할까요?
+   [Y] 이동  [N] 현재 스테이지 유지
+```
+
+### For large-scale changes:
+
+```
+🔄 이 작업은 큰 변경이 필요해 보여요.
+   03 Planning 스테이지에서 설계를 먼저 검토할까요?
+   [Y] 이동  [N] 현재 스테이지 유지
+```
+
+### When current stage is appropriate:
+
+No output - work continues silently.
+
+## Skill Files
+
+```
+stage-routing/
+├── README.md              # This file
+└── prompts/
+    └── analyze.md         # Analysis prompt template
+```
+
+## Usage Scenarios
+
+### Scenario 1: Bug Found During Implementation
+
+```
+Current: 06-implementation
+User: "이 코드에서 버그가 발생해. 수정해줘"
+
+AI Output:
+🔄 08 QA 스테이지로 이동해서 버그를 수정할까요?
+   [Y] 이동  [N] 현재 스테이지 유지
+```
+
+### Scenario 2: Stay in Current Stage
+
+```
+Current: 06-implementation
+User: "버튼 컴포넌트 구현해줘"
+
+→ No stage change suggestion, work proceeds directly
+```
+
+### Scenario 3: Large-Scale Change Detected
+
+```
+Current: 06-implementation
+User: "전체 아키텍처를 마이크로서비스로 변경하고 싶어"
+
+AI Output:
+🔄 이 작업은 큰 변경이 필요해 보여요.
+   03 Planning 스테이지에서 설계를 먼저 검토할까요?
+   [Y] 이동  [N] 현재 스테이지 유지
+```
+
+### Scenario 4: Design Change Request
+
+```
+Current: 06-implementation
+User: "이 부분 디자인을 다시해볼래?"
+
+AI Output:
+🔄 04 UI/UX 스테이지로 되돌아가서 다시 진행할까요?
+   [Y] 이동  [N] 현재 스테이지 유지
+```
+
+## Integration Points
+
+- **HANDOFF.md**: Loop-back transitions are recorded
+- **progress.json**: Stage changes update progress state
+- **loopback_history.json**: Full transition history maintained
+
+## Related Commands
+
+- `/goto <stage>` - Execute stage transition
+- `/goto --list` - View available stages
+- `/goto --history` - View transition history
+- `/status` - Check current stage
+
+## Related Skills
+
+- `stage-transition` - Handles forward progression
+- `smart-handoff` - Generates HANDOFF.md on transition

package/template/.claude/skills/stage-routing/prompts/analyze.md

@@ -0,0 +1,135 @@
+# Stage Routing Analysis Prompt
+
+Analyze the current user request and determine the optimal pipeline stage.
+
+## Analysis Context
+
+- **Current Stage**: {{CURRENT_STAGE}}
+- **User Request**: {{USER_PROMPT}}
+- **Configuration**: Read from `config/stage_routing.jsonc`
+
+## Analysis Steps
+
+### Step 1: Extract Keywords
+
+Scan the user prompt for keywords defined in `stage_routing.jsonc`:
+
+```
+Matched keywords by stage:
+{{#each MATCHED_STAGES}}
+- {{stage_id}}: [{{matched_keywords}}]
+{{/each}}
+```
+
+### Step 2: Detect Intent
+
+Based on keyword matches, classify the work type:
+
+| Intent | Description |
+|--------|-------------|
+| `ideation` | Creative exploration, new ideas |
+| `research` | Technical investigation, comparison |
+| `planning` | Architecture design, system structure |
+| `design` | UI/UX, wireframes, visual design |
+| `task_breakdown` | Sprint planning, task decomposition |
+| `implementation` | Feature development, coding |
+| `refactoring` | Code improvement, optimization |
+| `debugging` | Bug fixes, error resolution |
+| `testing` | Test creation, coverage |
+| `deployment` | CI/CD, release |
+
+### Step 3: Calculate Confidence
+
+```
+keyword_score = matched_keywords.length / stage.keywords.length
+trigger_score = matched_triggers.length / stage.triggers.length
+confidence = (keyword_score * 0.6) + (trigger_score * 0.4)
+```
+
+### Step 4: Detect Scale
+
+Check for large-scale change indicators:
+
+- Architecture keywords: "아키텍처", "시스템", "전체", "마이크로서비스"
+- Multi-module mentions
+- Migration or redesign language
+
+**If scale is LARGE** → Force recommendation: `03-planning`
+
+### Step 5: Make Recommendation
+
+**IMPORTANT: Do NOT expose internal analysis to users. Use simplified, friendly output.**
+
+```
+{{#if SHOULD_TRANSITION}}
+
+{{#if IS_LARGE_SCALE}}
+🔄 이 작업은 큰 변경이 필요해 보여요.
+   {{RECOMMENDED_STAGE_NAME}} 스테이지에서 설계를 먼저 검토할까요?
+   [Y] 이동  [N] 현재 스테이지 유지
+{{else}}
+🔄 {{RECOMMENDED_STAGE_NAME}} 스테이지로 이동해서 {{TASK_DESCRIPTION}}할까요?
+   [Y] 이동  [N] 현재 스테이지 유지
+{{/if}}
+
+{{else}}
+
+(No output - proceed with work in current stage)
+
+{{/if}}
+```
+
+### Stage Name Mappings (for friendly output)
+
+| Stage ID | Display Name | Task Description |
+|----------|--------------|------------------|
+| 01-brainstorm | 01 Brainstorm | 아이디어를 탐색 |
+| 02-research | 02 Research | 조사를 진행 |
+| 03-planning | 03 Planning | 설계를 검토 |
+| 04-ui-ux | 04 UI/UX | 디자인을 수정 |
+| 05-task-management | 05 Task | 작업을 분해 |
+| 06-implementation | 06 Implementation | 기능을 구현 |
+| 07-refactoring | 07 Refactoring | 코드를 개선 |
+| 08-qa | 08 QA | 버그를 수정 |
+| 09-testing | 09 Testing | 테스트를 작성 |
+| 10-deployment | 10 Deployment | 배포를 진행 |
+
+## Decision Matrix
+
+| Current Stage | Request Type | Recommendation |
+|---------------|--------------|----------------|
+| Any | Bug fix | → 08-qa |
+| Any | Test creation | → 09-testing |
+| Any | Architecture change | → 03-planning |
+| 06-impl | Small bug | Stay (fix inline) |
+| 06-impl | Feature request | Stay |
+| 08-qa | New feature | → 06-implementation |
+
+## Scale-Based Routing
+
+### Small Scale (Stay)
+- Single file change
+- No new dependencies
+- No structural changes
+
+### Medium Scale (Consider)
+- 4-10 files affected
+- Single module change
+- 1-2 new dependencies
+
+### Large Scale (Force Planning)
+- 10+ files affected
+- Architecture change
+- Core dependency changes
+- System-wide impact
+
+## Output Variables
+
+| Variable | Description |
+|----------|-------------|
+| `SHOULD_TRANSITION` | Boolean: recommend stage change |
+| `RECOMMENDED_STAGE` | Target stage ID |
+| `CONFIDENCE` | Match confidence (0-100%) |
+| `DETECTED_INTENT` | Classified work type |
+| `MATCHED_KEYWORDS` | Keywords that matched |
+| `REASONING` | Explanation for recommendation |

package/template/CLAUDE.md

@@ -174,6 +174,7 @@ Visualizes context usage, tool activity, and todo progress in the statusline.
 | `/goto <stage>` | Jump to previous stage (intentional loop-back) |
 | `/goto --list` | Show available stages for loop-back |
 | `/goto --history` | Show loop-back history |
+| `/goto <stage> --reason <text>` | Loop-back with recorded reason |
 
 ### Configuration Commands
 | Command | Description |
@@ -218,6 +219,7 @@ Visualizes context usage, tool activity, and todo progress in the statusline.
 | Skill | Trigger | Description |
 |-------|---------|-------------|
 | `stage-transition` | "completed", "/next" | Stage completion detection and transition automation |
+| `stage-routing` | Work type keywords detected | Automatic stage recommendation based on prompt analysis |
 | `context-compression` | Token 50k+ | Context compression and state save |
 | `smart-handoff` | Stage completion | Smart context extraction and HANDOFF generation |
 | `ai-collaboration` | `/collaborate` | Multi-AI collaboration orchestration |

package/template/config/stage_routing.jsonc

@@ -0,0 +1,94 @@
+{
+  "$schema": "../../schemas/stage-routing.schema.json",
+  "description": "Stage routing configuration for automatic prompt analysis and stage recommendation",
+
+  "routing": {
+    "01-brainstorm": {
+      "keywords": ["아이디어", "idea", "concept", "탐색", "explore", "브레인스토밍", "brainstorm", "가능성", "제안", "창의", "발상"],
+      "triggers": ["~하면 어떨까", "what if", "어떤 방법", "새로운 기능 아이디어", "다른 접근", "아이디어 필요"],
+      "intent": "ideation",
+      "description": "Creative exploration and idea generation"
+    },
+    "02-research": {
+      "keywords": ["조사", "research", "분석", "analyze", "기술 스택", "라이브러리", "library", "API", "비교", "compare", "평가"],
+      "triggers": ["알아봐", "investigate", "비교해", "찾아봐", "어떤 기술", "조사해", "검토해"],
+      "intent": "research",
+      "description": "Technical research and analysis"
+    },
+    "03-planning": {
+      "keywords": ["설계", "architecture", "구조", "plan", "아키텍처", "모듈", "시스템", "구성", "design", "청사진"],
+      "triggers": ["설계해", "구조를", "어떻게 구성", "아키텍처 변경", "재설계", "구조 잡아", "시스템 설계"],
+      "intent": "planning",
+      "description": "Architecture and system design"
+    },
+    "04-ui-ux": {
+      "keywords": ["UI", "UX", "디자인", "화면", "wireframe", "인터페이스", "레이아웃", "스타일", "컴포넌트", "사용자 경험"],
+      "triggers": ["화면 만들어", "디자인", "UI 변경", "레이아웃 수정", "인터페이스", "와이어프레임"],
+      "intent": "design",
+      "description": "UI/UX design and wireframing"
+    },
+    "05-task-management": {
+      "keywords": ["태스크", "task", "작업 분해", "우선순위", "스프린트", "sprint", "일정", "계획", "업무", "할 일"],
+      "triggers": ["작업을 나눠", "우선순위 정해", "스프린트 계획", "일정 조정", "태스크 생성", "작업 분해"],
+      "intent": "task_breakdown",
+      "description": "Task breakdown and sprint planning"
+    },
+    "06-implementation": {
+      "keywords": ["구현", "implement", "개발", "코드", "build", "기능", "만들어", "추가해", "작성", "코딩"],
+      "triggers": ["구현해", "개발해", "코드 작성", "기능 추가", "만들어줘", "build", "개발 시작"],
+      "intent": "implementation",
+      "description": "Feature implementation and coding"
+    },
+    "07-refactoring": {
+      "keywords": ["리팩토링", "refactor", "개선", "최적화", "optimize", "클린", "정리", "성능", "performance"],
+      "triggers": ["리팩토링해", "코드 개선", "성능 최적화", "정리해", "클린업", "개선해"],
+      "intent": "refactoring",
+      "description": "Code refactoring and optimization"
+    },
+    "08-qa": {
+      "keywords": ["버그", "bug", "수정", "fix", "오류", "error", "문제", "안됨", "에러", "이슈", "장애"],
+      "triggers": ["버그 수정", "문제 해결", "오류 나", "고쳐", "안 돼", "fix", "에러 발생", "작동 안함"],
+      "intent": "debugging",
+      "description": "Bug fixing and quality assurance"
+    },
+    "09-testing": {
+      "keywords": ["테스트", "test", "검증", "coverage", "E2E", "단위", "unit", "통합", "integration", "TDD"],
+      "triggers": ["테스트 작성", "테스트 추가", "커버리지", "검증해", "E2E 테스트", "테스트 코드"],
+      "intent": "testing",
+      "description": "Testing and test coverage"
+    },
+    "10-deployment": {
+      "keywords": ["배포", "deploy", "CI/CD", "릴리스", "release", "production", "출시", "publish", "운영"],
+      "triggers": ["배포해", "릴리스", "프로덕션", "출시해", "배포 설정", "CI/CD 구성"],
+      "intent": "deployment",
+      "description": "Deployment and CI/CD configuration"
+    }
+  },
+
+  "analysis": {
+    "confidence_threshold": 0.6,
+    "auto_transition": false,
+    "require_user_confirmation": true,
+    "min_keyword_matches": 2
+  },
+
+  "scale_detection": {
+    "small": {
+      "file_count_max": 3,
+      "description": "Minor changes, stay in current stage"
+    },
+    "medium": {
+      "file_count_max": 10,
+      "description": "Module-level changes, consider related stage"
+    },
+    "large": {
+      "file_count_min": 10,
+      "description": "Architecture changes, recommend 03-planning"
+    }
+  },
+
+  "indicators": {
+    "large_scale_keywords": ["전체", "아키텍처", "architecture", "시스템", "대규모", "전면", "마이크로서비스", "모놀리스"],
+    "force_planning_triggers": ["전체 재설계", "아키텍처 변경", "시스템 구조", "마이그레이션"]
+  }
+}