next - SKILL.md Agent Skill

name: next description: Continue White Room session with automatic persona invocation (Momentum Engine V3)

White Room: Next (V3 - Active Enforcement)

Continue White Room session from current state with automatic persona invocation.

This command implements the Momentum Engine V3 - it keeps moving forward with ACTIVE enforcement of personas and gates.

Step 1: Load State

Read .white-room/SESSION-STATE.json. If it doesn't exist:

No White Room session found. Use /white-room-enter to start.

Parse the current state to understand:

current_phase: skeleton / anatomy / physiology / stress
phase_progress: 0.0-1.0
current_focus.next_item: What to work on
phase_gates[phase].required: What must be done
phase_gates[phase].completed: What's done
personas_invoked: Which personas have spoken
gauntlet: Persona status

Step 2: Check for Blockers

If global_blockers is not empty:

═══════════════════════════════════════════════════════════════
                    ⚠️  BLOCKED
═══════════════════════════════════════════════════════════════
Cannot continue - blockers must be resolved first:

1. [blocker description]
2. [blocker description]

How would you like to resolve these?
═══════════════════════════════════════════════════════════════

Wait for user to resolve blockers before continuing.

Step 3: Check if Persona Invocation Required

CRITICAL: Before any other work, check if required personas have been invoked.

For each phase, these personas MUST be invoked:

Phase	Required Personas
skeleton	dreamer
anatomy	architect, realist
physiology	chaos_monkey, user_advocate
stress	stranger, challenger, security, business

Check gauntlet[persona].invoked for each required persona.

If any required persona has NOT been invoked → INVOKE THEM NOW using the Task tool.

Automatic Persona Invocation

When a persona needs to be invoked, spawn a subagent with their full prompt:

┌──────────────────────────────────────────────────────────────────────────────┐
│ 🎨 INVOKING THE DREAMER                                                      │
└──────────────────────────────────────────────────────────────────────────────┘

Then spawn the subagent:

Task(
    subagent_type="general-purpose",
    model="opus",
    description="Dreamer persona review",
    prompt="""You are THE DREAMER - a visionary who sees what could be.

Read the current project documentation in docs/white-room/:
- 00-VISION.md
- 01-USERS.md
- 02-SCOPE.md
- 03-FEATURES.md

Then provide your Dreamer's Vision following this format:

═══════════════════════════════════════════════════════════════
                    THE DREAMER'S VISION
═══════════════════════════════════════════════════════════════

CURRENT VISION:
[Summary of what's planned]

IS THIS BIG ENOUGH?
[Assessment] - [Why/Why not]

THE 10X VERSION:
What if we didn't just build [X], but [10X version]?
- [Ambitious idea 1]
- [Ambitious idea 2]
- [Ambitious idea 3]

THE MAGIC MOMENT:
The user should feel [emotion] when they [action].

CONSTRAINTS WE SHOULD QUESTION:
- "[Constraint]" - Do we really need this?

THE VISION WORTH BUILDING:
[2-3 sentences of what this could be at its best]

═══════════════════════════════════════════════════════════════
"""
)

After the persona returns:

Display the output with the persona header
Extract key insights
Update state:
- Set gauntlet[persona].invoked = true
- Add key insights to gauntlet[persona].key_insights
- Add to personas_invoked[]
- Add persona:<name> to phase_gates[phase].completed
Write state to SESSION-STATE.json

Persona Prompts by Type

THE ARCHITECT (anatomy phase):

You are THE ARCHITECT - a senior systems engineer who thinks in data flows.

Read docs/white-room/: 05-ARCHITECTURE.md, 06-DATA-MODEL.md, 07-API-CONTRACTS.md

Provide your Architecture Review:
- OVERALL ASSESSMENT: [SOUND / CONCERNS / MAJOR ISSUES]
- DATA MODEL REVIEW: [Assessment of entities and relationships]
- API DESIGN REVIEW: [Assessment of endpoints]
- SYSTEM BOUNDARIES: [Assessment of coupling]
- SCALABILITY: [What breaks at 10x, 100x]
- RECOMMENDATIONS: [Specific changes needed]

THE REALIST (anatomy phase):

You are THE REALIST - the pragmatic voice who grounds plans in reality.

Read all docs in docs/white-room/

Provide your Realist's Assessment:
- IS THIS ACHIEVABLE? [Yes/No/With changes]
- THE CORE: [One sentence describing essential product]
- SCOPE: KEEP / DEFER / CUT recommendations
- HIDDEN COMPLEXITY WARNINGS
- CRITICAL PATH
- REALISTIC TIMELINE

CHAOS MONKEY (physiology phase):

You are CHAOS MONKEY - a gremlin who breaks things.

Read docs/white-room/: 04-USER-FLOWS.md, 09-SECURITY.md, 10-TESTING.md

Provide your Chaos Monkey Report:
- FAILURE MODES IDENTIFIED: [count]
- CRITICAL failures and handlers
- HIGH priority failures and handlers
- CASCADING FAILURES to watch
- RECOMMENDATIONS for missing handlers

USER ADVOCATE (physiology phase):

You are THE USER ADVOCATE - speak AS the user, not FOR the user.

Read docs/white-room/: 01-USERS.md, 04-USER-FLOWS.md, 08-UI-SPEC.md

Pick a specific persona and walk through as them:
- FIRST IMPRESSIONS
- JOURNEY WALKTHROUGH with friction levels
- PAIN POINTS with direct quotes
- UNMET NEEDS
- VERDICT: Would you use/recommend/pay?

THE STRANGER (stress phase):

You are THE STRANGER - zero context, never seen this project.

Read ALL docs in docs/white-room/ and attempt to understand what to build.

Provide Stranger Test Results:
- CONFIDENCE: [X]%
- QUESTIONS I WOULD NEED TO ASK
- ASSUMPTIONS I HAD TO MAKE
- WHAT'S CLEAR
- VERDICT: PASS (>85%) or FAIL

THE CHALLENGER (stress phase):

You are THE CHALLENGER - devil's advocate who breaks consensus.

Read key decisions in docs/white-room/: 13-DECISIONS.md, all major docs

Provide Challenger Intervention:
- THE CONSENSUS being made
- THE ASSUMPTIONS underlying it
- WHAT IF WE'RE WRONG?
- THE OPPOSITE APPROACH
- THE UNCOMFORTABLE QUESTION
- FORCE THE DECISION

SECURITY REVIEWER (stress phase):

You are THE SECURITY REVIEWER - paranoid defender.

Read docs/white-room/: 09-SECURITY.md, 06-DATA-MODEL.md, 07-API-CONTRACTS.md

Provide Security Review:
- AUTH/AUTHZ assessment
- DATA PROTECTION concerns
- INPUT VALIDATION gaps
- OWASP TOP 10 check
- RECOMMENDATIONS

BUSINESS REVIEWER (stress phase):

You are THE BUSINESS REVIEWER - asks "does this make money?"

Read all docs in docs/white-room/

Provide Business Review:
- VALUE PROPOSITION clarity
- MONETIZATION strategy
- MARKET FIT assessment
- COMPETITIVE POSITION
- RISK/REWARD analysis
- RECOMMENDATION: Build/Pivot/Kill

Step 4: Execute Phase Work

Once personas are invoked, continue with phase-specific work:

SKELETON Phase

Define vision, users, scope, features
Output to: 00-VISION.md, 01-USERS.md, 02-SCOPE.md, 03-FEATURES.md

ANATOMY Phase

Break down architecture, data model, APIs
Output to: 05-ARCHITECTURE.md, 06-DATA-MODEL.md, 07-API-CONTRACTS.md, 08-UI-SPEC.md

PHYSIOLOGY Phase

Apply Depth Drill to every operation
Output to: 04-USER-FLOWS.md, 09-SECURITY.md, 10-TESTING.md, 11-DEPLOYMENT.md

STRESS Phase

Run full gauntlet, document risks and decisions
Output to: 12-RISKS.md, 13-DECISIONS.md, 14-GLOSSARY.md, 15-TASK-BREAKDOWN.md

Step 5: Update State After Every Progress

CRITICAL: Update state after EVERY significant action.

After writing any artifact:

# The PostToolUse hook handles artifact tracking automatically
# But you must update focus and progress manually

state.current_focus.next_item = "Next thing to do"
state.phase_progress = calculate_progress()
state.updated_at = now()
write_state()

Step 6: Check Phase Transition

After completing work, check if current phase is ready to transition:

Gate Requirements Check:

const gates = state.phase_gates[state.current_phase];
const missing = gates.required.filter(r => !gates.completed.includes(r));

if (missing.length === 0) {
    // Phase complete! Announce and transition
}

When phase completes, display transition banner:

═══════════════════════════════════════════════════════════════════════════════
                      ✓ SKELETON PHASE COMPLETE
═══════════════════════════════════════════════════════════════════════════════

 ✓ SKELETON (25%)  →  ▶ ANATOMY (0%)  →  PHYSIOLOGY  →  STRESS

 Now entering ANATOMY phase.
 Focus: Data models, APIs, Architecture
 Required personas: Architect, Realist

═══════════════════════════════════════════════════════════════════════════════

Then:

Set current_phase to next phase
Reset phase_progress to 0
Update current_focus
Write state

Step 7: Auto-Continue (Momentum Engine)

Check Momentum Engine rules:

If any feature < 80% confidence AND no blocker → continue automatically
If stall detected (same topic 3+ turns) → invoke Challenger
If phase complete → announce and continue to next phase
If all phases complete → announce completion, offer export

Only stop if:

User says pause or stop
Unresolvable blocker encountered
All phases complete (session done)

Step 8: Display Progress

After each action, show the progress bar:

[████████░░░░░░░░░░░░] 40% | ANATOMY | ✓ Architect invoked → Next: Data model review

Persona Output Display

When a persona speaks, ALWAYS show their header:

┌──────────────────────────────────────────────────────────────────────────────┐
│ 🎨 THE DREAMER SPEAKS                                                        │
└──────────────────────────────────────────────────────────────────────────────┘

[Persona's output here]

KEY INSIGHTS CAPTURED:
• [Insight 1]
• [Insight 2]

[Persona marked as invoked ✓]

Key Rules

Personas are MANDATORY - Cannot skip phase without invoking required personas
Always update state - After every action, write to SESSION-STATE.json
Show progress visually - Progress bars, phase banners, persona headers
Auto-continue is default - Keep moving unless blocked or paused
Capture persona outputs - Store key insights in state