@stella-studio/ck 1.0.0

package/.claude/commands/worktree.md

@@ -0,0 +1,109 @@
+---
+description: Create isolated git worktree for parallel development
+argument-hint: [feature-description] OR [project] [feature] (monorepo)
+---
+
+Create an isolated git worktree for parallel feature development.
+
+## Workflow
+
+### Step 1: Get Repo Info
+
+```bash
+node .claude/scripts/worktree.cjs info --json
+```
+
+Parse JSON response for: `repoType`, `baseBranch`, `projects`, `worktreeRoot`, `worktreeRootSource`.
+
+### Step 2: Detect Branch Prefix
+
+From user's description:
+- "fix", "bug", "error", "issue" → `fix`
+- "refactor", "restructure", "rewrite" → `refactor`
+- "docs", "documentation", "readme" → `docs`
+- "test", "spec", "coverage" → `test`
+- "chore", "cleanup", "deps" → `chore`
+- "perf", "performance", "optimize" → `perf`
+- Default → `feat`
+
+### Step 3: Convert to Slug
+
+"add authentication system" → `add-auth`
+"fix login bug" → `login-bug`
+Max 50 chars, kebab-case.
+
+### Step 4: Handle Monorepo
+
+If `repoType === "monorepo"` and project not specified, use AskUserQuestion:
+```javascript
+AskUserQuestion({
+  questions: [{
+    header: "Project",
+    question: "Which project for the worktree?",
+    options: projects.map(p => ({ label: p.name, description: p.path })),
+    multiSelect: false
+  }]
+})
+```
+
+### Step 5: Execute
+
+**Monorepo:**
+```bash
+node .claude/scripts/worktree.cjs create "<PROJECT>" "<SLUG>" --prefix <TYPE>
+```
+
+**Standalone:**
+```bash
+node .claude/scripts/worktree.cjs create "<SLUG>" --prefix <TYPE>
+```
+
+**Options:**
+- `--prefix` - Branch type: feat|fix|refactor|docs|test|chore|perf
+- `--worktree-root <path>` - Override default location (only if needed)
+- `--json` - JSON output
+- `--dry-run` - Preview
+
+### Step 6: Install Dependencies
+
+Based on project context, run in background:
+- `bun.lock` → `bun install`
+- `pnpm-lock.yaml` → `pnpm install`
+- `yarn.lock` → `yarn install`
+- `package-lock.json` → `npm install`
+- `poetry.lock` → `poetry install`
+- `requirements.txt` → `pip install -r requirements.txt`
+- `Cargo.toml` → `cargo build`
+- `go.mod` → `go mod download`
+
+## Commands
+
+| Command | Usage | Description |
+|---------|-------|-------------|
+| `create` | `create [project] <feature>` | Create worktree |
+| `remove` | `remove <name-or-path>` | Remove worktree |
+| `info` | `info` | Repo info with worktree location |
+| `list` | `list` | List worktrees |
+
+## Example
+
+```
+User: /worktree fix the login validation bug
+
+Claude: [Runs: node .claude/scripts/worktree.cjs info --json]
+        repoType: standalone
+        worktreeRoot: /home/user/worktrees
+        worktreeRootSource: sibling directory
+
+        [Prefix: fix, Slug: login-validation-bug]
+        [Runs: node .claude/scripts/worktree.cjs create "login-validation-bug" --prefix fix]
+
+Output: Worktree created at /home/user/worktrees/my-project-login-validation-bug
+```
+
+## Notes
+
+- Script auto-detects superproject, monorepo, and standalone repos
+- Default worktree location is smart: superproject > monorepo > sibling
+- Use `--worktree-root` only to override defaults
+- Env templates (`.env*.example`) auto-copied with `.example` suffix removed

package/.claude/commands-archived/code/auto.md

@@ -0,0 +1,203 @@
+---
+description: ⚡⚡⚡ [AUTO] Start coding & testing an existing plan ("trust me bro")
+argument-hint: [plan] [all-phases-yes-or-no] (default: yes)
+---
+
+**MUST READ** `CLAUDE.md` then **THINK HARDER** to start working on the following plan follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules:
+<plan>$ARGUMENTS</plan>
+
+## Arguments
+- $PLAN: $1 (Mention specific plan or auto detected, default: latest plan)
+- $ALL_PHASES: $2 (`Yest` to finish all phases in one run or `No` to implement phase-by-phase and wait for confirmation, default is `Yes`)
+
+---
+
+## Role Responsibilities
+- You are a senior software engineer who must study the provided implementation plan end-to-end before writing code.
+- Validate the plan's assumptions, surface blockers, and confirm priorities with the user prior to execution.
+- Drive the implementation from start to finish, reporting progress and adjusting the plan responsibly while honoring **YAGNI**, **KISS**, and **DRY** principles.
+
+**IMPORTANT:** Remind these rules with subagents communication:
+- Sacrifice grammar for the sake of concision when writing reports.
+- In reports, list any unresolved questions at the end, if any.
+- Ensure token efficiency while maintaining high quality.
+- DO NOT stop until you finish all phases.
+- If this is a frontend project, use any of these available skills/tools to verify the implementation: `chrome`, `chrome-devtools`
+
+---
+
+## Step 0: Plan Detection & Phase Selection
+
+**If `$PLAN` is empty:**
+1. Find latest `plan.md` in `./plans` | `find ./plans -name "plan.md" -type f -exec stat -f "%m %N" {} \; 2>/dev/null | sort -rn | head -1 | cut -d' ' -f2-`
+2. Parse plan for phases and status, auto-select next incomplete (prefer IN_PROGRESS or earliest Planned)
+
+**If `$PLAN` provided:** Use that plan and detect which phase to work on (auto-detect or use argument like "phase-2").
+
+**Output:** `✓ Step 0: [Plan Name] - [Phase Name]`
+
+**Subagent Pattern (use throughout):**
+```
+Task(subagent_type="[type]", prompt="[task description]", description="[brief]")
+```
+
+---
+
+## Workflow Sequence
+
+**Rules:** Follow steps 1-5 in order. Each step requires output marker starting with "✓ Step N:". Mark each complete in `TodoWrite` before proceeding. Do not skip steps.
+
+---
+
+## Step 1: Analysis & Task Extraction
+Use `project-manager` agent to read plan file completely. Map dependencies between tasks. List ambiguities or blockers. Identify required skills/tools and activate from catalog. Parse phase file and extract actionable tasks.
+
+**TodoWrite Initialization & Task Extraction:**
+`project-manager` agent must respond back with:
+- Initialize `TodoWrite` with `Step 0: [Plan Name] - [Phase Name]` and all command steps (Step 1 through Step 5)
+- Read phase file (e.g., phase-01-preparation.md)
+- Look for tasks/steps/phases/sections/numbered/bulleted lists
+- MUST convert to `TodoWrite` tasks:
+  - Phase Implementation tasks → Step 2.X (Step 2.1, Step 2.2, etc.)
+  - Phase Testing tasks → Step 3.X (Step 3.1, Step 3.2, etc.)
+  - Phase Code Review tasks → Step 4.X (Step 4.1, Step 4.2, etc.)
+- Ensure each task has UNIQUE name (increment X for each task)
+- Add tasks to `TodoWrite` after their corresponding command step
+
+**Output:** `✓ Step 1: Found [N] tasks across [M] phases - Ambiguities: [list or "none"]`
+
+Mark Step 1 complete in `TodoWrite`, mark Step 2 in_progress.
+
+---
+
+## Step 2: Implementation
+
+Implement selected plan phase step-by-step following extracted tasks (Step 2.1, Step 2.2, etc.). Mark tasks complete as done. For UI work, call `ui-ux-designer` subagent: "Implement [feature] UI per ./docs/design-guidelines.md". Use `ai-multimodal` skill for image assets, imagemagick in `media-processing` skill for editing. Run type checking and compile to verify no syntax errors.
+
+**Output:** `✓ Step 2: Implemented [N] files - [X/Y] tasks complete, compilation passed`
+
+Mark Step 2 complete in `TodoWrite`, mark Step 3 in_progress.
+
+---
+
+## Step 3: Testing
+
+Write tests covering happy path, edge cases, and error cases. Call `tester` subagent: "Run test suite for plan phase [phase-name]". If ANY tests fail: STOP, call `debugger` subagent: "Analyze failures: [details]", fix all issues, re-run `tester`. Repeat until 100% pass.
+
+**Testing standards:** Unit tests may use mocks for external dependencies (APIs, DB). Integration tests use test environment. E2E tests use real but isolated data. Forbidden: commenting out tests, changing assertions to pass, TODO/FIXME to defer fixes.
+
+**Output:** `✓ Step 3: Tests [X/X passed] - All requirements met`
+
+**Validation:** If X ≠ total, Step 3 INCOMPLETE - do not proceed.
+
+Mark Step 3 complete in `TodoWrite`, mark Step 4 in_progress.
+
+---
+
+## Step 4: Code Review (Smart Auto-Handling)
+
+Call `code-reviewer` subagent: "Review code changes in **Step 2** of plan phase [phase-name]. Check security, performance, architecture, YAGNI/KISS/DRY. Return score (X/10), critical issues list, warnings list, suggestions list."
+
+**Auto-Handling Logic (max 3 cycles):**
+
+```
+cycle = 0
+LOOP:
+  1. Run code-reviewer → get score, critical_count, warnings, suggestions
+  2. LOG findings: "Review: [score]/10 | Critical: [N] | Warnings: [N] | Suggestions: [N]"
+  3. IF score >= 9.5 AND critical_count == 0:
+     → Output: "✓ Step 4: Code reviewed - [score]/10 - Auto-approved ([warnings] warnings logged)"
+     → PROCEED to Step 5
+  4. ELSE IF critical_count > 0 AND cycle < 3:
+     → Output: "⚙ Step 4: Auto-fixing [critical_count] critical issues (cycle [cycle+1]/3)"
+     → Implement fixes for critical issues
+     → Re-run tester to verify no regressions
+     → cycle++, GOTO LOOP
+  5. ELSE IF critical_count > 0 AND cycle >= 3:
+     → ESCALATE TO USER (auto-fix exhausted)
+     → DISPLAY all findings to user (critical, warnings, suggestions with file:line)
+     → Use AskUserQuestion:
+       - "Fix remaining issues manually" → implement, restart cycle counter
+       - "Approve with noted issues" → proceed with warnings
+       - "Abort workflow" → stop
+  6. ELSE (no critical, but score < 9.5):
+     → Output: "✓ Step 4: Code reviewed - [score]/10 - Approved ([warnings] warnings, [suggestions] suggestions logged)"
+     → PROCEED to Step 5
+```
+
+**Critical issues:** Security vulnerabilities (XSS, SQL injection, OWASP), performance bottlenecks, architectural violations, principle violations.
+
+**Output formats:**
+- Auto-approved: `✓ Step 4: Code reviewed - 9.8/10 - Auto-approved (2 warnings logged)`
+- After auto-fix: `✓ Step 4: Code reviewed - 7.2/10 → Auto-fixed 2 critical → 9.5/10 - Approved`
+- Escalation: `⚠ Step 4: 3 fix cycles exhausted, [N] critical remain - User input required`
+
+**Validation:** Step 4 INCOMPLETE if critical issues > 0 AND user hasn't approved.
+
+Mark Step 4 complete in TodoWrite, mark Step 5 in_progress.
+
+---
+
+## Step 5: Finalize
+
+1. **STATUS UPDATE - BOTH MANDATORY - PARALLEL EXECUTION:**
+- **Call** `project-manager` sub-agent: "Update plan status in [plan-path]. Mark plan phase [phase-name] as DONE with timestamp. Update roadmap."
+- **Call** `docs-manager` sub-agent: "Update docs for plan phase [phase-name]. Changed files: [list]."
+
+2. **ONBOARDING CHECK:** Detect onboarding requirements (API keys, env vars, config) + generate summary report with next steps.
+- If this is the last phase: use `AskUserQuestion` tool to ask if user wants to set up onboarding requirements.
+
+3. **AUTO-COMMIT (after steps 1 and 2 completes):**
+- **Call** `git-manager` subagent to handle git operation.
+- Run only if: Steps 1 and 2 successful + Tests passed
+- Auto-stage, commit with conventional commit message based on actual changes
+
+**Validation:** Steps 1 and 2 must complete successfully. Step 3 (auto-commit) runs only if conditions met.
+
+Mark Step 5 complete in `TodoWrite`.
+
+**Important:**
+If $ALL_PHASES is `Yes`, proceed to the next phase automatically.
+If $ALL_PHASES is `No`, wait for user confirmation before proceeding to the next phase:
+- Use `AskUserQuestion` tool to ask if user wants to proceed to the next phase: "**Phase workflow finished. Ready for next plan phase.**"
+
+## Summary report
+If this is the last phase, generate a concise summary report.
+Use `AskUserQuestion` tool to ask these questions:
+- If user wants to preview the report with `/preview` slash command.
+- If user wants to archive the plan with `/plan:archive` slash command.
+
+---
+
+## Critical Enforcement Rules
+
+**Step outputs must follow unified format:** `✓ Step [N]: [Brief status] - [Key metrics]`
+
+**Examples:**
+- Step 0: `✓ Step 0: [Plan Name] - [Phase Name]`
+- Step 1: `✓ Step 1: Found [N] tasks across [M] phases - Ambiguities: [list]`
+- Step 2: `✓ Step 2: Implemented [N] files - [X/Y] tasks complete`
+- Step 3: `✓ Step 3: Tests [X/X passed] - All requirements met`
+- Step 4: `✓ Step 4: Code reviewed - [0] critical issues`
+- Step 5: `✓ Step 5: Finalize - Status updated - Git committed`
+
+**If any "✓ Step N:" output missing, that step is INCOMPLETE.**
+
+**TodoWrite tracking required:** Initialize at Step 0, mark each step complete before next.
+
+**Mandatory subagent calls:**
+- Step 3: `tester`
+- Step 4: `code-reviewer`
+- Step 5: `project-manager` AND `docs-manager` AND `git-manager`
+
+**Blocking gates:**
+- Step 3: Tests must be 100% passing
+- Step 4: Critical issues must be 0
+
+**REMEMBER:**
+- Do not skip steps. Do not proceed if validation fails.
+- One plan phase at a time. Do not proceed to the next phase until the current phase is complete and validated.
+- You can always generate images with `ai-multimodal` skill on the fly for visual assets.
+- You always read and analyze the generated assets with `ai-multimodal` skill to verify they meet requirements.
+- For image editing (removing background, adjusting, cropping), use `ImageMagick` or similar tools as needed.
+- If this is a frontend project, use any of these available skills/tools to verify the implementation: `chrome`, `chrome-devtools`.

package/.claude/commands-archived/code/no-test.md

@@ -0,0 +1,174 @@
+---
+description: ⚡⚡ Start coding an existing plan (no testing)
+argument-hint: [plan]
+---
+
+**MUST READ** `CLAUDE.md` then **THINK HARDER** to start working on the following plan follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules:
+<plan>$ARGUMENTS</plan>
+
+---
+
+## Role Responsibilities
+- You are a senior software engineer who must study the provided implementation plan end-to-end before writing code.
+- Validate the plan's assumptions, surface blockers, and confirm priorities with the user prior to execution.
+- Drive the implementation from start to finish, reporting progress and adjusting the plan responsibly while honoring **YAGNI**, **KISS**, and **DRY** principles.
+
+**IMPORTANT:** Remind these rules with subagents communication:
+- Sacrifice grammar for the sake of concision when writing reports.
+- In reports, list any unresolved questions at the end, if any.
+- Ensure token efficiency while maintaining high quality.
+
+---
+
+## Step 0: Plan Detection & Phase Selection
+
+**If `$ARGUMENTS` is empty:**
+1. Find latest `plan.md` in `./plans` | `find ./plans -name "plan.md" -type f -exec stat -f "%m %N" {} \; 2>/dev/null | sort -rn | head -1 | cut -d' ' -f2-`
+2. Parse plan for phases and status, auto-select next incomplete (prefer IN_PROGRESS or earliest Planned)
+
+**If `$ARGUMENTS` provided:** Use that plan and detect which phase to work on (auto-detect or use argument like "phase-2").
+
+**Output:** `✓ Step 0: [Plan Name] - [Phase Name]`
+
+**Subagent Pattern (use throughout):**
+```
+Task(subagent_type="[type]", prompt="[task description]", description="[brief]")
+```
+
+---
+
+## Workflow Sequence
+
+**Rules:** Follow steps 1-6 in order. Each step requires output marker starting with "✓ Step N:". Mark each complete in TodoWrite before proceeding. Do not skip steps.
+
+---
+
+## Step 1: Analysis & Task Extraction
+
+Read plan file completely. Map dependencies between tasks. List ambiguities or blockers. Identify required skills/tools and activate from catalog. Parse phase file and extract actionable tasks.
+
+**TodoWrite Initialization & Task Extraction:**
+- Initialize TodoWrite with `Step 0: [Plan Name] - [Phase Name]` and all command steps (Step 1 through Step 6)
+- Read phase file (e.g., phase-01-preparation.md)
+- Look for tasks/steps/phases/sections/numbered/bulleted lists
+- MUST convert to TodoWrite tasks:
+  - Phase Implementation tasks → Step 2.X (Step 2.1, Step 2.2, etc.)
+  - Phase Code Review tasks → Step 3.X (Step 3.1, Step 3.2, etc.)
+- Ensure each task has UNIQUE name (increment X for each task)
+- Add tasks to TodoWrite after their corresponding command step
+
+**Output:** `✓ Step 1: Found [N] tasks across [M] phases - Ambiguities: [list or "none"]`
+
+Mark Step 1 complete in TodoWrite, mark Step 2 in_progress.
+
+---
+
+## Step 2: Implementation
+
+Implement selected plan phase step-by-step following extracted tasks (Step 2.1, Step 2.2, etc.). Mark tasks complete as done. For UI work, call `ui-ux-designer` subagent: "Implement [feature] UI per ./docs/design-guidelines.md". Use `ai-multimodal` skill for image assets, `imagemagick` for editing. Run type checking and compile to verify no syntax errors.
+
+**Output:** `✓ Step 2: Implemented [N] files - [X/Y] tasks complete, compilation passed`
+
+Mark Step 2 complete in TodoWrite, mark Step 3 in_progress.
+
+---
+
+## Step 3: Code Review & Approval ⏸ BLOCKING GATE
+
+Call `code-reviewer` subagent: "Review changes for plan phase [phase-name]. Check security, performance, architecture, YAGNI/KISS/DRY. Return score (X/10), critical issues list, warnings list, suggestions list."
+
+**Display + Approve Flow (optimized for speed):**
+
+```
+1. Run code-reviewer → get score, critical_count, warnings, suggestions
+
+2. DISPLAY FULL FINDINGS + SUMMARY TO USER:
+   ┌─────────────────────────────────────────┐
+   │ Code Review Results: [score]/10         │
+   ├─────────────────────────────────────────┤
+   │ Summary: [what implemented]             │
+   │ (Tests skipped per user request)        │
+   ├─────────────────────────────────────────┤
+   │ Critical Issues ([N]): MUST FIX         │
+   │  - [issue] at [file:line]               │
+   │ Warnings ([N]): SHOULD FIX              │
+   │  - [issue] at [file:line]               │
+   │ Suggestions ([N]): NICE TO HAVE         │
+   │  - [suggestion]                         │
+   └─────────────────────────────────────────┘
+
+3. Use AskUserQuestion (header: "Review & Approve"):
+   IF critical_count > 0:
+     - "Fix critical + approve" → implement critical fixes, PROCEED to Step 4
+     - "Approve anyway" → PROCEED to Step 4
+     - "Abort" → stop workflow
+   ELSE:
+     - "Approve" → PROCEED to Step 4
+     - "Abort" → stop workflow
+```
+
+**Note:** No fix loop to respect speed intent. If user wants iterative fixes, use `/code` instead.
+
+**Critical issues:** Security vulnerabilities (XSS, SQL injection, OWASP), performance bottlenecks, architectural violations, principle violations.
+
+**Output formats:**
+- Waiting: `⏸ Step 3: Code reviewed - [score]/10 - WAITING for user approval`
+- Approved: `✓ Step 3: Code reviewed - [score]/10 - User approved`
+
+**Validation:** Step 3 INCOMPLETE until user explicitly approves.
+
+Mark Step 3 complete in TodoWrite, mark Step 4 in_progress.
+
+---
+
+## Step 4: Finalize
+
+**Prerequisites:** User approved in Step 3 (verified above).
+
+1. **STATUS UPDATE - BOTH MANDATORY - PARALLEL EXECUTION:**
+- **Call** `project-manager` sub-agent: "Update plan status in [plan-path]. Mark plan phase [phase-name] as DONE with timestamp. Update roadmap."
+- **Call** `docs-manager` sub-agent: "Update docs for plan phase [phase-name]. Changed files: [list]."
+
+2. **ONBOARDING CHECK:** Detect onboarding requirements (API keys, env vars, config) + generate summary report with next steps.
+
+3. **AUTO-COMMIT (after steps 1 and 2 completes):**
+- Run only if: Steps 1 and 2 successful + User approved + Tests passed
+- Auto-stage, commit with conventional commit message based on actual changes
+
+**Validation:** Steps 1 and 2 must complete successfully. Step 3 (auto-commit) runs only if conditions met.
+
+Mark Step 4 complete in TodoWrite.
+
+**Phase workflow finished. Ready for next plan phase.**
+
+---
+
+## Critical Enforcement Rules
+
+**Step outputs must follow unified format:** `✓ Step [N]: [Brief status] - [Key metrics]`
+
+**Examples:**
+- Step 0: `✓ Step 0: [Plan Name] - [Phase Name]`
+- Step 1: `✓ Step 1: Found [N] tasks across [M] phases - Ambiguities: [list]`
+- Step 2: `✓ Step 2: Implemented [N] files - [X/Y] tasks complete`
+- Step 3: `✓ Step 3: Code reviewed - [score]/10 - User approved`
+- Step 4: `✓ Step 4: Finalize - Status updated - Git committed`
+
+**If any "✓ Step N:" output missing, that step is INCOMPLETE.**
+
+**TodoWrite tracking required:** Initialize at Step 0, mark each step complete before next.
+
+**Mandatory subagent calls:**
+- Step 3: `code-reviewer`
+- Step 4: `project-manager` AND `docs-manager` (when user approves)
+
+**Blocking gates:**
+- Step 3: User must explicitly approve (via AskUserQuestion)
+- Step 4: Both `project-manager` and `docs-manager` must complete successfully
+
+**REMEMBER:**
+- Do not skip steps. Do not proceed if validation fails. Do not assume approval without user response.
+- One plan phase per command run. Command focuses on single plan phase only.
+- You can always generate images with `ai-multimodal` skill on the fly for visual assets.
+- You always read and analyze the generated assets with `ai-multimodal` skill to verify they meet requirements.
+- For image editing (removing background, adjusting, cropping), use `media-processing` skill or similar tools as needed.

package/.claude/commands-archived/code/parallel.md

@@ -0,0 +1,100 @@
+---
+description: ⚡ Execute parallel or sequential phases based on plan structure
+argument-hint: [plan-path]
+---
+
+Execute plan: <plan>$ARGUMENTS</plan>
+
+**IMPORTANT:** Activate needed skills. Ensure token efficiency. Sacrifice grammar for concision.
+
+## Workflow
+
+### 1. Plan Analysis
+- Read `plan.md` from given path
+- **Check for:** Dependency graph, Execution strategy, Parallelization Info, File Ownership matrix
+- **Decision:** IF parallel-executable → Step 2A, ELSE → Step 2B
+
+### 2A. Parallel Execution
+1. Parse execution strategy (which phases concurrent/sequential, file ownership)
+2. Launch multiple `fullstack-developer` agents simultaneously for parallel phases
+   - Pass: phase file path, environment info, file ownership boundaries
+3. Wait for parallel group completion, verify no conflicts
+4. Execute sequential phases (one agent per phase after dependencies)
+5. Proceed to Step 3
+
+### 2B. Sequential Execution
+Follow `./.claude/rules/primary-workflow.md`:
+1. Use main agent step by step
+2. Read `plan.md`, implement phases one by one
+3. Use `project-manager` for progress updates
+4. Use `ui-ux-designer` for frontend
+5. Run type checking after each phase
+6. Proceed to Step 3
+
+### 3. Testing
+- Use `tester` for full suite (NO fake data/mocks)
+- If fail: `debugger` → fix → repeat
+
+### 4. Code Review (Interactive Cycle)
+
+Call `code-reviewer` subagent: "Review all changes from parallel/sequential execution. Check security, performance, architecture, YAGNI/KISS/DRY. Return score (X/10), critical issues list, warnings list, suggestions list."
+
+**Interactive Review-Fix Cycle (max 3 cycles):**
+
+```
+cycle = 0
+LOOP:
+  1. Run code-reviewer → get score, critical_count, warnings, suggestions
+
+  2. DISPLAY FULL FINDINGS TO USER:
+     ┌─────────────────────────────────────────┐
+     │ Code Review Results: [score]/10         │
+     ├─────────────────────────────────────────┤
+     │ Critical Issues ([N]): MUST FIX         │
+     │  - [issue] at [file:line]               │
+     │ Warnings ([N]): SHOULD FIX              │
+     │  - [issue] at [file:line]               │
+     │ Suggestions ([N]): NICE TO HAVE         │
+     │  - [suggestion]                         │
+     └─────────────────────────────────────────┘
+
+  3. Use AskUserQuestion (header: "Review"):
+     IF critical_count > 0:
+       - "Fix critical issues" → implement critical fixes, re-run tester
+       - "Fix all issues" → implement all fixes, re-run tester
+       - "Approve anyway" → proceed with noted issues
+       - "Abort" → stop workflow
+     ELSE:
+       - "Fix warnings/suggestions" → implement selected fixes
+       - "Approve" → proceed
+       - "Abort" → stop workflow
+
+  4. IF user selects fix option AND cycle < 3:
+     → Implement requested fixes
+     → Re-run tester to verify no regressions
+     → cycle++
+     → GOTO LOOP (re-run code-reviewer)
+
+  5. IF cycle >= 3 AND still has issues:
+     → Output: "⚠ 3 review cycles completed. Final decision required."
+     → Use AskUserQuestion:
+       - "Approve with noted issues"
+       - "Abort workflow"
+
+  6. ON APPROVE: PROCEED to Step 5
+```
+
+### 5. Project Management & Docs
+- If approved: `project-manager` + `docs-manager` in parallel (update plans, docs, roadmap)
+- If rejected: fix → repeat
+
+### 6. Onboarding
+- Guide user step by step (1 question at a time)
+
+### 7. Final Report
+- Summary, guide, next steps
+- Ask to commit (use `git-manager` if yes)
+
+**Examples:**
+- Parallel: "Phases 1-3 parallel, then 4" → Launch 3 agents → Wait → Launch 1 agent
+- Sequential: "Phase 1 → 2 → 3" → Main agent implements each phase