@thierrynakoa/fire-flow 10.0.0

package/commands/fire-brainstorm.md

@@ -0,0 +1,413 @@
+---
+description: Dedicated ideation and exploration before implementation
+---
+
+# /fire-brainstorm
+
+> Explore ideas thoroughly before committing to implementation
+
+---
+
+## Purpose
+
+A dedicated ideation phase inspired by superpowers:brainstorming. Forces divergent thinking, explores alternatives, and documents decisions BEFORE writing code. Prevents premature implementation and ensures requirements are understood.
+
+---
+
+## Arguments
+
+```yaml
+arguments:
+  topic:
+    required: true
+    type: string
+    description: "What to brainstorm - feature, architecture, problem, etc."
+    examples:
+      - "/fire-brainstorm 'user authentication system'"
+      - "/fire-brainstorm 'how to handle file uploads'"
+      - "/fire-brainstorm 'database schema for orders'"
+
+optional_flags:
+  --constraints: "Comma-separated constraints to consider"
+  --time-box: "Limit brainstorm duration (e.g., '15min')"
+  --perspectives: "Number of alternative approaches to explore (default: 3)"
+  --output: "Save brainstorm to file (default: .planning/brainstorms/)"
+  --no-questions: "Skip clarifying questions, use assumptions"
+```
+
+---
+
+## Process
+
+### Step 1: Initialize Brainstorm Session
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+                      DOMINION FLOW ► BRAINSTORM SESSION
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Topic: {topic}
+Mode: Exploration (no code yet)
+```
+
+### Step 2: Clarifying Questions (Unless --no-questions)
+
+**MANDATORY: Understand before exploring.**
+
+```markdown
+## Clarifying Questions
+
+Before exploring solutions, I need to understand the problem space.
+
+### Scope Questions
+1. What is the primary user/use case for this?
+2. What systems/components does this interact with?
+3. Are there existing patterns in the codebase to follow?
+
+### Constraint Questions
+4. What are the non-negotiables (must-haves)?
+5. What are known limitations (tech stack, budget, time)?
+6. Are there security/compliance requirements?
+
+### Context Questions
+7. Has this been attempted before? What happened?
+8. What does "success" look like?
+9. Who are the stakeholders?
+```
+
+**Wait for user response before proceeding.**
+
+### Step 3: Problem Decomposition
+
+```markdown
+## Problem Decomposition
+
+### Core Challenge
+{Single sentence describing the essential problem}
+
+### Sub-Problems
+1. {Sub-problem 1}
+   - Why it matters: {reason}
+   - Complexity: Low | Medium | High
+
+2. {Sub-problem 2}
+   - Why it matters: {reason}
+   - Complexity: Low | Medium | High
+
+3. {Sub-problem 3}
+   - Why it matters: {reason}
+   - Complexity: Low | Medium | High
+
+### Dependencies
+- {Sub-problem 1} must be solved before {Sub-problem 3}
+- {Sub-problem 2} can be solved in parallel
+
+### Risk Areas
+- {Area with highest uncertainty}
+- {Area most likely to change}
+```
+
+### Step 4: Explore Alternatives (Divergent Thinking)
+
+**IMPORTANT: Explore at least 3 different approaches.**
+
+```markdown
+## Alternative Approaches
+
+### Approach A: {Name}
+
+**Summary:** {One-line description}
+
+**How it works:**
+{2-3 sentence explanation}
+
+**Pros:**
+- {Pro 1}
+- {Pro 2}
+- {Pro 3}
+
+**Cons:**
+- {Con 1}
+- {Con 2}
+
+**Best when:**
+{Scenario where this is ideal}
+
+**Complexity:** {Low | Medium | High}
+
+**Skills Library Match:** @skills-library/{category}/{skill}.md
+
+---
+
+### Approach B: {Name}
+
+**Summary:** {One-line description}
+
+**How it works:**
+{2-3 sentence explanation}
+
+**Pros:**
+- {Pro 1}
+- {Pro 2}
+- {Pro 3}
+
+**Cons:**
+- {Con 1}
+- {Con 2}
+
+**Best when:**
+{Scenario where this is ideal}
+
+**Complexity:** {Low | Medium | High}
+
+**Skills Library Match:** @skills-library/{category}/{skill}.md
+
+---
+
+### Approach C: {Name}
+
+**Summary:** {One-line description}
+
+**How it works:**
+{2-3 sentence explanation}
+
+**Pros:**
+- {Pro 1}
+- {Pro 2}
+- {Pro 3}
+
+**Cons:**
+- {Con 1}
+- {Con 2}
+
+**Best when:**
+{Scenario where this is ideal}
+
+**Complexity:** {Low | Medium | High}
+
+**Skills Library Match:** @skills-library/{category}/{skill}.md
+```
+
+### Step 5: Trade-off Analysis
+
+```markdown
+## Trade-off Matrix
+
+| Criteria | Weight | Approach A | Approach B | Approach C |
+|----------|--------|------------|------------|------------|
+| Simplicity | 3 | 8 | 5 | 7 |
+| Performance | 2 | 6 | 9 | 7 |
+| Maintainability | 3 | 7 | 4 | 8 |
+| Time to Implement | 2 | 9 | 3 | 6 |
+| Scalability | 2 | 5 | 9 | 7 |
+| **Weighted Total** | | **84** | **68** | **82** |
+
+### Analysis
+
+**Approach A wins on:** {criteria}
+**Approach B wins on:** {criteria}
+**Approach C wins on:** {criteria}
+
+### Hidden Risks
+
+| Approach | Hidden Risk | Mitigation |
+|----------|-------------|------------|
+| A | {risk} | {mitigation} |
+| B | {risk} | {mitigation} |
+| C | {risk} | {mitigation} |
+```
+
+### Step 6: Recommendation
+
+```markdown
+## Recommendation
+
+### Recommended Approach: {A | B | C}
+
+**Why:**
+{2-3 sentences explaining the decision}
+
+**Key factors:**
+1. {Factor 1}
+2. {Factor 2}
+3. {Factor 3}
+
+### Implementation Sketch
+
+```
+{High-level architecture diagram or flow}
+```
+
+### First Steps
+1. {First concrete step}
+2. {Second concrete step}
+3. {Third concrete step}
+
+### Open Questions (To Resolve During Implementation)
+- {Question 1}
+- {Question 2}
+
+### Decision Record
+
+| Decision | Rationale | Alternatives Considered |
+|----------|-----------|------------------------|
+| {Decision 1} | {Why} | {What else was considered} |
+| {Decision 2} | {Why} | {What else was considered} |
+```
+
+### Step 7: Save Brainstorm Document
+
+**Create:** `.planning/brainstorms/{topic-slug}-{timestamp}.md`
+
+### Step 8: Sabbath Rest (Context Persistence)
+
+> *Like humans need sleep to reset, AI agents need state files to resume after context resets.*
+
+**MANDATORY:** Update CONSCIENCE.md to track brainstorm sessions:
+
+```markdown
+## Recent Brainstorms
+- [{topic}](.planning/brainstorms/{filename}.md) - {timestamp}
+  - Recommended: Approach {X}
+  - Status: {COMPLETE | PENDING_REVIEW}
+  - Next: /fire-2-plan or implementation
+```
+
+**Also create/update:** `.claude/fire-brainstorm.local.md`
+
+```markdown
+---
+last_session: {timestamp}
+topic: "{topic}"
+status: complete
+recommended_approach: "{approach name}"
+output_file: ".planning/brainstorms/{filename}.md"
+---
+
+# Brainstorm Session State
+
+## Current Session
+- Topic: {topic}
+- Started: {timestamp}
+- Status: {in_progress | complete}
+
+## Session History
+| Date | Topic | Outcome | File |
+|------|-------|---------|------|
+| {date} | {topic} | Approach {X} | {file} |
+```
+
+This ensures:
+- CONSCIENCE.md tracks all brainstorm decisions for project continuity
+- `.local.md` preserves session state if context resets mid-brainstorm
+
+```markdown
+# Brainstorm: {Topic}
+
+**Date:** {timestamp}
+**Status:** COMPLETE
+**Outcome:** Recommended Approach {X}
+
+---
+
+{Full brainstorm content from steps 2-6}
+
+---
+
+## Next Steps
+
+- [ ] Review with stakeholders (if needed)
+- [ ] Create detailed plan: `/fire-2-plan` with this as input
+- [ ] Begin implementation
+
+---
+
+*Brainstorm facilitated by Dominion Flow*
+```
+
+---
+
+## Output Display
+
+```
+╔══════════════════════════════════════════════════════════════════════════════╗
+║ ✓ BRAINSTORM COMPLETE                                                        ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                                                                              ║
+║  Topic: {topic}                                                              ║
+║  Approaches Explored: 3                                                      ║
+║  Recommended: Approach {X} - {name}                                          ║
+║                                                                              ║
+║  Key Decision: {one-line summary}                                            ║
+║                                                                              ║
+║  Saved: .planning/brainstorms/{filename}.md                                  ║
+║                                                                              ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║ NEXT STEPS                                                                   ║
+├──────────────────────────────────────────────────────────────────────────────┤
+║                                                                              ║
+║  → Review the brainstorm document                                            ║
+║  → Run `/fire-2-plan` to create detailed implementation plan                ║
+║  → Or discuss further if questions remain                                    ║
+║                                                                              ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## Integration with Dominion Flow
+
+### Before New Project
+```bash
+/fire-brainstorm "project architecture for {idea}"
+# Then
+/fire-1-new
+```
+
+### Before Planning Phase
+```bash
+/fire-brainstorm "how to implement {phase feature}"
+# Then
+/fire-2-plan N
+```
+
+### Standalone Exploration
+```bash
+/fire-brainstorm "should we use GraphQL or REST"
+# Decision documented, no immediate action
+```
+
+---
+
+## Anti-Patterns Blocked
+
+- **Jumping to code:** Brainstorm MUST complete before implementation
+- **Single solution thinking:** Forces exploration of alternatives
+- **Undocumented decisions:** All decisions recorded with rationale
+- **Premature optimization:** Focus on understanding, not perfection
+
+---
+
+## Success Criteria
+
+### Required Outputs
+- [ ] Problem clearly decomposed
+- [ ] At least 3 alternatives explored
+- [ ] Trade-offs analyzed with criteria
+- [ ] Clear recommendation with rationale
+- [ ] Brainstorm document saved
+
+### Quality Markers
+- Alternatives are genuinely different (not variations)
+- Pros/cons are specific, not generic
+- Recommendation matches stated criteria
+- Open questions are acknowledged
+
+---
+
+## References
+
+- **Inspiration:** superpowers:brainstorming
+- **Template:** `@templates/brainstorm.md`
+- **Skills Search:** `/fire-search` for relevant patterns
+- **Brand:** `@references/ui-brand.md`

package/commands/fire-complete-milestone.md

@@ -0,0 +1,270 @@
+---
+description: Archive completed milestone and prepare for next version with WARRIOR validation
+---
+
+# /fire-complete-milestone
+
+> Archive milestone, create historical record, and prepare for next cycle with WARRIOR validation
+
+---
+
+## Purpose
+
+Mark milestone complete, archive to milestones/, and update VISION.md and REQUIREMENTS.md. Creates a historical record of what shipped and prepares the project for the next milestone.
+
+**Creates:**
+- `.planning/milestones/v{version}-VISION.md` - Archived roadmap
+- `.planning/milestones/v{version}-REQUIREMENTS.md` - Archived requirements
+- Git tag `v{version}`
+
+---
+
+## Arguments
+
+```yaml
+arguments:
+  version:
+    required: true
+    type: string
+    description: "Version number to complete (e.g., '1.0', '1.1', '2.0')"
+    example: "/fire-complete-milestone 1.0"
+```
+
+---
+
+## Process
+
+### Step 0: Pre-flight Check - WARRIOR Validation
+
+**MANDATORY: Check for verification before archiving.**
+
+```bash
+ls .planning/v{version}-VERIFICATION.md 2>/dev/null
+```
+
+**If no verification file:**
+```
++------------------------------------------------------------------------------+
+| WARNING: No Verification Found                                                |
++------------------------------------------------------------------------------+
+|                                                                              |
+|  No verification record found for v{version}.                                |
+|                                                                              |
+|  Recommended: Run `/fire-4-verify` first to ensure:                         |
+|    - All must-haves are met                                                  |
+|    - 70-point validation passed                                              |
+|    - No critical gaps                                                        |
+|                                                                              |
+|  Continue anyway? (verification will be noted as "skipped")                  |
+|                                                                              |
++------------------------------------------------------------------------------+
+```
+
+Use AskUserQuestion:
+- header: "Verification"
+- question: "No verification found. How do you want to proceed?"
+- options:
+  - "Run verification first (Recommended)" - Route to /fire-4-verify
+  - "Continue without verification" - Proceed with warning noted
+
+### Step 1: Verify Readiness
+
+Check all phases in milestone have completed plans (RECORD.md exists):
+
+```bash
+for phase_dir in .planning/phases/*/; do
+  [ -f "${phase_dir}RECORD.md" ] && echo "COMPLETE: $phase_dir" || echo "MISSING: $phase_dir"
+done
+```
+
+Present milestone scope and stats. Wait for confirmation.
+
+### Step 2: Gather Stats
+
+- Count phases, plans, tasks completed
+- Calculate git range, file changes, LOC
+- Extract timeline from git log
+
+```bash
+# Git stats
+git log --oneline --since="[milestone start]" | wc -l
+git diff --stat $(git log --format="%H" --since="[milestone start]" | tail -1)..HEAD
+```
+
+Present summary, confirm.
+
+### Step 3: Extract Accomplishments
+
+Read all phase RECORD.md files in milestone range. Extract 4-6 key accomplishments.
+
+```
++------------------------------------------------------------------------------+
+| v{version} ACCOMPLISHMENTS                                                   |
++------------------------------------------------------------------------------+
+|                                                                              |
+|  Key accomplishments:                                                        |
+|    1. {accomplishment from RECORD.md}                                       |
+|    2. {accomplishment from RECORD.md}                                       |
+|    3. {accomplishment from RECORD.md}                                       |
+|    4. {accomplishment from RECORD.md}                                       |
+|                                                                              |
+|  Stats:                                                                      |
+|    - Phases: {count}                                                         |
+|    - Plans executed: {count}                                                 |
+|    - Requirements fulfilled: {count}/{total}                                 |
+|    - Files changed: {count}                                                  |
+|                                                                              |
++------------------------------------------------------------------------------+
+```
+
+Present for approval.
+
+### Step 4: Archive Milestone
+
+Create `.planning/milestones/v{version}-VISION.md`:
+- Extract full phase details from VISION.md
+- Include completion timestamps
+- Add accomplishment summary
+
+Update VISION.md to one-line summary with link:
+
+```markdown
+## Archived Milestones
+
+- [v{version}](milestones/v{version}-VISION.md) - {one-line summary} (shipped {date})
+```
+
+### Step 5: Archive Requirements
+
+Create `.planning/milestones/v{version}-REQUIREMENTS.md`:
+- Mark all v1 requirements as complete (checkboxes checked)
+- Note requirement outcomes (validated, adjusted, dropped)
+
+Delete `.planning/REQUIREMENTS.md` (fresh one created for next milestone).
+
+### Step 6: Update PROJECT.md
+
+Add "Current State" section with shipped version:
+
+```markdown
+## Current State
+
+**Latest Release:** v{version} - {name}
+**Shipped:** {date}
+
+Key accomplishments:
+- {accomplishment 1}
+- {accomplishment 2}
+
+## Next Milestone Goals
+<!-- Defined by /fire-1-new or /fire-new-milestone -->
+```
+
+### Step 7: Commit and Tag
+
+Stage all changes:
+
+```bash
+git add .planning/milestones/ .planning/PROJECT.md .planning/VISION.md .planning/CONSCIENCE.md
+git commit -m "$(cat <<'EOF'
+chore: archive v{version} milestone
+
+Key accomplishments:
+- {accomplishment 1}
+- {accomplishment 2}
+- {accomplishment 3}
+
+Phases: {count} | Requirements: {count}
+EOF
+)"
+```
+
+Create annotated tag:
+
+```bash
+git tag -a v{version} -m "[milestone summary]"
+```
+
+Use AskUserQuestion:
+- header: "Push Tag"
+- question: "Push tag v{version} to remote?"
+- options:
+  - "Yes, push tag" - git push origin v{version}
+  - "No, keep local" - Done
+
+### Step 8: Sabbath Rest - Context Persistence
+
+Update persistent state:
+
+```markdown
+## .claude/dominion-flow.local.md
+
+### Milestone Completion
+- Version: v{version}
+- Completed: {timestamp}
+- Accomplishments: {count}
+- Next: Run /fire-new-milestone to start next cycle
+```
+
+---
+
+## Completion Display
+
+```
++------------------------------------------------------------------------------+
+| MILESTONE v{version} ARCHIVED                                                |
++------------------------------------------------------------------------------+
+|                                                                              |
+|  Archived Files:                                                             |
+|    - .planning/milestones/v{version}-VISION.md                              |
+|    - .planning/milestones/v{version}-REQUIREMENTS.md                         |
+|                                                                              |
+|  Git Tag: v{version}                                                         |
+|  Commit: {hash}                                                              |
+|                                                                              |
++------------------------------------------------------------------------------+
+| NEXT UP                                                                      |
++------------------------------------------------------------------------------+
+|                                                                              |
+|  -> Run `/fire-new-milestone` to start the next milestone cycle             |
+|     (questioning -> research -> requirements -> roadmap)                     |
+|                                                                              |
+|  -> Or run `/fire-5-handoff` to create a session handoff first              |
+|                                                                              |
++------------------------------------------------------------------------------+
+```
+
+---
+
+## Success Criteria
+
+- [ ] Verification status checked (WARRIOR validation)
+- [ ] All phases have RECORD.md files
+- [ ] Milestone archived to `.planning/milestones/v{version}-VISION.md`
+- [ ] Requirements archived to `.planning/milestones/v{version}-REQUIREMENTS.md`
+- [ ] `.planning/REQUIREMENTS.md` deleted (fresh for next milestone)
+- [ ] VISION.md collapsed to one-line entry
+- [ ] PROJECT.md updated with current state
+- [ ] Git tag v{version} created
+- [ ] Commit successful
+- [ ] Sabbath Rest state updated
+- [ ] User knows next steps
+
+---
+
+## Critical Rules
+
+- **Verify before archiving:** Check for /fire-4-verify results
+- **Archive before deleting:** Always create archive files before updating/deleting originals
+- **One-line summary:** Collapsed milestone in VISION.md should be single line with link
+- **Context efficiency:** Archive keeps VISION.md and REQUIREMENTS.md constant size per milestone
+- **Fresh requirements:** Next milestone starts with `/fire-new-milestone` which includes requirements definition
+
+---
+
+## References
+
+- **Related:** `/fire-new-milestone` - Start next milestone cycle
+- **Related:** `/fire-4-verify` - Verify phase/milestone completion
+- **Template:** `@templates/milestone-archive.md`
+- **Brand:** `@references/ui-brand.md`