opencode-goopspec 0.1.3 → 0.1.4

package/commands/goop-plan.md

@@ -1,184 +1,185 @@
 ---
 name: goop-plan
-description: Start the Planning Phase
+description: Create specification and blueprint from discovery interview
 phase: plan
-next-step: "When planning is complete and requirements are clear, lock the specification"
+requires: interview_complete
+next-step: "When planning is complete, lock the specification"
 next-command: /goop-specify
 alternatives:
+  - command: /goop-discuss
+    when: "If discovery interview was not completed"
   - command: /goop-research
-    when: "If there are unknowns or technology questions to investigate"
+    when: "If there are unknowns to investigate"
   - command: /goop-pause
     when: "To save progress and continue later"
 ---
 
 # /goop-plan
 
-**Start the Planning Phase.** Capture intent, clarify requirements, and prepare for execution.
+**Create Specification and Blueprint.** Transform discovery interview into executable plans.
 
 ## Usage
 
 ```bash
-/goop-plan [brief description of task]
+/goop-plan
 ```
 
-## Orchestrator Role
+## Gate Requirement
 
-**YOU conduct the interview directly.** Do NOT spawn agents for conversation. Only spawn agents when it's time to BUILD documents.
+```
++================================================================+
+|  DISCOVERY GATE: Interview must be complete before planning.    |
+|  This ensures we build the RIGHT thing.                         |
++================================================================+
+```
 
-Why: The interview builds shared understanding. That understanding stays in YOUR context and informs how you delegate. Spawning for conversation fragments knowledge.
+**Required before this command:**
+- `interviewComplete: true` (check via `goop_state({ action: "get" })`)
+- `.goopspec/REQUIREMENTS.md` exists
 
-## Process
+**If not satisfied:** Refuse and redirect to `/goop-discuss`
 
-### Phase 1: Setup
+**CRITICAL: Never read or edit .goopspec/state.json directly. Always use `goop_state` tool.**
 
-**Execute these checks BEFORE any user interaction:**
+## Orchestrator Role
 
-**1.1 Check for existing project documents:**
-```
-goop_status()
-Read(".goopspec/SPEC.md")
-Read(".goopspec/BLUEPRINT.md")
-Read(".goopspec/CHRONICLE.md")
-```
+**You check the gate, then spawn the planner.** The planner creates SPEC.md and BLUEPRINT.md.
 
-**1.2 If documents exist, offer archive:**
+## Tools Used
 
-Use `question` tool:
-- header: "Existing Project"
-- question: "I found existing project documents. How would you like to proceed?"
-- options:
-  - "Archive and start fresh (Recommended)" — Move current docs to archive, extract learnings, start new project
-  - "Continue existing project" — Resume work on current spec (exit planning, run /goop-status)
-  - "Overwrite without archiving" — Replace documents (loses history)
+| Tool | Purpose in This Command |
+|------|------------------------|
+| `goop_status` | Check current phase and gate requirements |
+| `goop_spec` | Validate interview complete, load existing specs |
+| `memory_search` | Find prior architecture decisions |
+| `memory_decision` | Record new planning decisions |
+| `goop_reference` | Load spec/blueprint templates |
 
-**On "Archive and start fresh":**
-```
-task({
-  subagent_type: "goop-writer",
-  description: "Archive current milestone",
-  prompt: `
-    Archive the current project:
-    1. Read .goopspec/SPEC.md and .goopspec/CHRONICLE.md
-    2. Generate RETROSPECTIVE.md summarizing:
-       - What was built
-       - Key decisions made
-       - Learnings for next time
-    3. Move all documents to .goopspec/archive/[milestone-name]/
-    4. Clear working documents (keep archive/)
-    5. Return ARCHIVE COMPLETE with summary
-  `
-})
-```
-Then continue to Phase 2.
+**Hook Support:** `tool.execute.after` may auto-transition to specify phase.
 
-**On "Continue existing":** Exit command. Suggest `/goop-status` for current state.
+---
 
-**On "Overwrite":** Warn user, then continue to Phase 2.
+## Process
 
-**1.3 Initialize if needed:**
-```bash
-mkdir -p .goopspec
-```
+### Phase 1: Gate Check
+
+**Execute BEFORE anything else:**
 
-**1.4 Search memory for context:**
 ```
-memory_search({ query: "project preferences architecture decisions [user's topic]", limit: 5 })
+goop_status()
+goop_state({ action: "get" })          # NEVER read state.json directly
+Read(".goopspec/REQUIREMENTS.md")
 ```
 
-Store any relevant findings - use them to skip questions you already know answers to.
-
-### Phase 2: Deep Questioning
+**1.1 Check interviewComplete:**
 
-**Display stage banner:**
 ```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- GOOPSPEC ▸ PLANNING
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+IF state.interviewComplete != true:
+  REFUSE with:
+  
+  ## 🔮 GoopSpec · Gate Blocked
+  
+  ✗ Discovery interview required before planning.
+  
+  → Run: `/goop-discuss`
+  
+  ---
+  
+  EXIT command.
 ```
 
-**2.1 Open the conversation:**
+**1.2 Check REQUIREMENTS.md exists:**
 
-If `$ARGUMENTS` provided:
-> "You want to **[argument]**. Let me understand this better."
+```
+IF .goopspec/REQUIREMENTS.md does not exist:
+  REFUSE with:
+  
+  ## 🔮 GoopSpec · Gate Blocked
+  
+  ✗ No discovery output found.
+  
+  → Run: `/goop-discuss`
+  
+  ---
+  
+  EXIT command.
+```
 
-Otherwise:
-> "What do you want to build?"
+**1.3 Gate passed:**
 
-Wait for response. This gives context for intelligent follow-ups.
+```
+## 🔮 GoopSpec · Planning
 
-**2.2 Follow the thread:**
+✓ Discovery gate passed
 
-Based on their response, ask follow-up questions. Use the `question` tool with options that probe what they mentioned.
+⏳ Creating specification and blueprint...
 
-Keep following threads. Each answer opens new areas:
-- What excited them about this idea
-- What problem sparked it
-- What vague terms mean concretely
-- What it would look like in use
-- What's already decided vs open
+---
+```
 
-**2.3 Memory-first questioning protocol:**
+### Phase 2: Check for Existing Documents
 
-Before asking ANYTHING:
-1. Check memory: `memory_search({ query: "[topic] preference" })`
-2. If found with high confidence: "I recall you prefer X for this. Still true? [Y/n]"
-3. If not found: Ask, then SAVE the answer with `memory_note`
+**2.1 Check for existing SPEC.md/BLUEPRINT.md:**
 
-**Never ask what you already know.**
+```
+Read(".goopspec/SPEC.md")
+Read(".goopspec/BLUEPRINT.md")
+```
 
-**2.4 Context checklist (gather all of these):**
+**2.2 If documents exist:**
 
-| Category | Questions to Answer |
-|----------|-------------------|
-| **Goal** | What is the ONE thing that must work? |
-| **Context** | Why now? What problem does this solve? |
-| **Success** | How do we know it's done? Observable outcomes? |
-| **Constraints** | Tech stack? Performance? Security? Timeline? |
-| **Scope** | What's explicitly NOT included? |
-| **UI/UX** | Visual direction? Key patterns? States to handle? |
+Use `question` tool:
+- header: "Existing Project"
+- question: "I found existing project documents. How would you like to proceed?"
+- options:
+  - "Archive and start fresh (Recommended)" — Move current docs to archive, create new
+  - "Continue existing project" — Resume work (exit, run /goop-status)
+  - "Overwrite without archiving" — Replace documents (loses history)
 
-Don't ask all at once. Weave naturally through conversation.
+**On "Archive":** Spawn writer to archive, then continue.
+**On "Continue":** Exit, suggest `/goop-status`.
+**On "Overwrite":** Warn, then continue.
 
-**2.5 Strategy decision gate:**
+### Phase 3: Load Context
 
-When you could write a clear SPEC.md, use `question` tool:
+**3.1 Load discovery interview:**
 
-- header: "Strategy"
-- question: "I understand what you're building. How should we proceed?"
-- options:
-  - "Create specification (Recommended)" — I'll create SPEC.md and BLUEPRINT.md now
-  - "Research first" — Investigate unknowns before planning (/goop-research)
-  - "Map codebase first" — Understand existing code before planning (/goop-map-codebase)
-  - "Keep exploring" — I want to share more context
+```
+Read(".goopspec/REQUIREMENTS.md")
+```
+
+Extract:
+- Vision
+- Must-haves (with acceptance criteria)
+- Constraints
+- Out of scope
+- Assumptions
+- Risks
 
-**On "Keep exploring":** Ask what they want to add, identify gaps, continue conversation.
+**3.2 Search memory:**
 
-**On "Research first":** 
 ```
-Suggest: "Run `/goop-research [topic]` to investigate, then return to `/goop-plan`"
+memory_search({ query: "[feature] architecture decisions patterns", limit: 5 })
 ```
-Exit command.
 
-**On "Map codebase":**
+**3.3 Load project knowledge:**
+
 ```
-Suggest: "Run `/goop-map-codebase` to understand the existing code, then return to `/goop-plan`"
+Read(".goopspec/PROJECT_KNOWLEDGE_BASE.md")  # If exists
 ```
-Exit command.
-
-**On "Create specification":** Continue to Phase 3.
 
-### Phase 3: Document Creation
+### Phase 4: Spawn Planner
 
-**Display stage banner:**
+**Display banner:**
 ```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- GOOPSPEC ▸ CREATING DOCUMENTS
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+## 🔮 GoopSpec · Creating Documents
+
+⏳ Spawning planner to create SPEC.md and BLUEPRINT.md...
 
-◆ Spawning planner to create SPEC.md and BLUEPRINT.md...
+---
 ```
 
-**Spawn goop-planner with full interview context:**
+**Spawn goop-planner with full context:**
 
 ```
 task({
@@ -186,147 +187,203 @@ task({
   description: "Create SPEC and BLUEPRINT",
   prompt: `
 ## TASK
-Create specification and blueprint for: [feature name]
-
-## CONTEXT FROM INTERVIEW
+Create specification and blueprint from discovery interview.
 
-### User Intent
-[The core "why" - what problem this solves, why now]
+## PROJECT CONTEXT
+[From PROJECT_KNOWLEDGE_BASE.md if exists]
+- Stack: [technologies]
+- Conventions: [naming, patterns]
 
-### Requirements Gathered
+## DISCOVERY INTERVIEW OUTPUT
+[Full content of REQUIREMENTS.md]
 
-**Must Have:**
-- [Requirement 1 from interview]
-- [Requirement 2 from interview]
-- [Requirement 3 from interview]
+### Vision
+[Vision section]
 
-**Nice to Have:**
-- [If mentioned]
+### Must-Haves
+[Must-haves with acceptance criteria]
 
-**Out of Scope:**
-- [Explicit exclusions from interview]
+### Constraints
+[Technical and practical constraints]
 
-### Technical Constraints
-- Stack: [from interview]
-- Performance: [from interview]
-- Security: [from interview]
+### Out of Scope
+[Explicit exclusions]
 
-### Success Criteria
-- [Observable outcome 1]
-- [Observable outcome 2]
+### Assumptions
+[Baseline assumptions]
 
-### UI/UX Requirements (if applicable)
-- Visual direction: [from interview]
-- Key patterns: [from interview]
-- States to handle: [loading, empty, error, success]
+### Risks
+[Identified risks with mitigations]
 
 ## INSTRUCTIONS
-1. Load templates:
-   - goop_reference({ name: "spec", type: "template" })
-   - goop_reference({ name: "blueprint", type: "template" })
-
-2. Create .goopspec/SPEC.md with:
-   - All must-haves as checkboxes with IDs (MH-01, MH-02)
-   - Nice-to-haves marked separately
-   - Clear out-of-scope section
-   - Success criteria
-
-3. Create .goopspec/BLUEPRINT.md with:
-   - Wave-based execution plan
-   - Each task is atomic and verifiable
-   - Dependencies mapped
-   - Estimated effort per wave
-
-4. Initialize .goopspec/CHRONICLE.md with:
+
+1. **Verify discovery completeness:**
+   - Vision defined? 
+   - Must-haves listed with acceptance criteria?
+   - Out of scope defined?
+   - Risks identified?
+   
+   If missing critical info, return BLOCKED.
+
+2. **Create .goopspec/SPEC.md:**
+   - Transform must-haves into formal requirements (MH1, MH2, etc.)
+   - Include acceptance criteria for each
+   - Add traceability section (will be filled after blueprint)
+   - Mark status as "Draft"
+
+3. **Create .goopspec/BLUEPRINT.md:**
+   - Design wave architecture
+   - Create tasks that cover ALL must-haves
+   - Add spec coverage to each task
+   - Build traceability matrix
+
+4. **Update .goopspec/SPEC.md:**
+   - Fill traceability matrix (must-have → tasks)
+   - Verify 100% coverage
+
+5. **Initialize .goopspec/CHRONICLE.md:**
    - Phase: plan → ready for specify
    - Documents created with timestamps
 
-5. Save key decisions to memory:
-   memory_decision({
-     decision: "[key architectural choice]",
-     reasoning: "[why]",
-     impact: "medium"
-   })
-
-6. Return: ## PLANNING COMPLETE with summary
-
-Write files IMMEDIATELY. Don't draft - commit to disk.
+6. **Save to memory:**
+   - Key architectural decisions
+   - Technology choices with rationale
+
+7. **Return XML response envelope** with:
+   - BLUEPRINT COMPLETE status
+   - Wave summary
+   - Traceability summary
+   - Handoff instructions
+
+## VERIFICATION
+Before returning COMPLETE:
+- [ ] Every must-have has mapped tasks
+- [ ] Every task has spec coverage
+- [ ] Traceability matrix shows 100%
+- [ ] SPEC.md has all sections filled
+- [ ] BLUEPRINT.md has verification commands
   `
 })
 ```
 
-### Phase 4: Handle Response
+### Phase 5: Handle Response
 
-**On `## PLANNING COMPLETE`:**
+**Parse XML response from planner.**
 
-Read created documents and present:
+**On `COMPLETE` status:**
+
+Read created documents:
+```
+Read(".goopspec/SPEC.md")
+Read(".goopspec/BLUEPRINT.md")
+```
 
+Display completion:
 ```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- GOOPSPEC ▸ PLANNING COMPLETE ✓
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+## 🔮 GoopSpec · Planning Complete
+
+✨ Blueprint created successfully
 
 **Feature:** [Name from SPEC.md]
 
-| Artifact   | Status  | Location               |
-|------------|---------|------------------------|
-| Spec       | Created | .goopspec/SPEC.md      |
-| Blueprint  | Created | .goopspec/BLUEPRINT.md |
-| Chronicle  | Created | .goopspec/CHRONICLE.md |
+| Document | Status | Location |
+|----------|--------|----------|
+| Spec | ✓ Created | .goopspec/SPEC.md |
+| Blueprint | ✓ Created | .goopspec/BLUEPRINT.md |
+| Chronicle | ✓ Created | .goopspec/CHRONICLE.md |
 
 **[N] must-haves** | **[M] waves** | **[P] tasks**
 
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+### Traceability
+| Must-Have | Covered By |
+|-----------|------------|
+| MH1 | Wave X, Tasks Y |
+| MH2 | Wave X, Tasks Y |
+
+✓ Coverage: 100%
 
-## ▸ Next Up
+### Next Step
 
 **Lock the specification** — Confirm requirements before execution
 
-`/goop-specify`
+→ `/goop-specify`
 
 ---
 
+Start a **new session** for fresh context, then run the command.
+
 **Also available:**
-- `/goop-research [topic]` — Investigate unknowns before specifying
-- `cat .goopspec/SPEC.md` — Review the specification
-- `cat .goopspec/BLUEPRINT.md` — Review the execution plan
+- `cat .goopspec/SPEC.md` — Review specification
+- `cat .goopspec/BLUEPRINT.md` — Review execution plan
+- `/goop-research [topic]` — Investigate unknowns first
+```
 
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+**Generate HANDOFF.md:**
+
+```
+Write(".goopspec/HANDOFF.md", `
+# Session Handoff
+
+**Generated:** [timestamp]
+**Phase:** plan
+
+## Accomplished
+- [x] Discovery interview completed
+- [x] SPEC.md created with [N] must-haves
+- [x] BLUEPRINT.md created with [M] waves, [P] tasks
+- [x] 100% traceability achieved
+
+## Current State
+- Phase: plan
+- Interview: complete
+- Spec: draft (not locked)
+
+## Next Session
+Run: /goop-specify
+
+## Files to Read
+1. .goopspec/SPEC.md — Requirements
+2. .goopspec/BLUEPRINT.md — Execution plan
+
+## Context Summary
+Planning complete for [feature]. [N] must-haves mapped to [P] tasks
+across [M] waves. Ready to lock specification.
+`)
 ```
 
-**On `## PLANNING BLOCKED`:**
+**On `BLOCKED` status:**
 
-Present blocker to user:
 ```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- GOOPSPEC ▸ PLANNING BLOCKED
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+## 🔮 GoopSpec · Planning Blocked
+
+✗ Cannot proceed
 
 **Blocker:** [From planner response]
 
 **Options:**
-1. Provide more context → continue planning
-2. Research the unknown → /goop-research
-3. Abort → /goop-pause
+1. Provide more context → `/goop-discuss`
+2. Research the unknown → `/goop-research [topic]`
+
+---
 ```
 
 Use `question` tool to get user choice.
 
-**On `## PLANNING PARTIAL`:**
+**On `PARTIAL` status:**
 
 Present what was created, explain gaps, offer to continue or restart.
 
-### Phase 5: Memory Persistence
+### Phase 6: Memory Persistence
 
-After successful planning, persist key context:
+After successful planning:
 
 ```
 memory_save({
   type: "note",
-  title: "Project: [Feature Name]",
-  content: "Building [summary]. Key decisions: [list]. Success = [criteria].",
-  concepts: ["project", "planning", "[domain]"],
-  importance: 0.8
+  title: "Plan: [Feature Name]",
+  content: "Created [N]-wave blueprint. Key decisions: [list]. Must-haves: [summary].",
+  concepts: ["planning", "blueprint", "[domain]"],
+  importance: 0.7
 })
 ```
 
@@ -334,103 +391,100 @@ memory_save({
 
 | File | Purpose |
 |------|---------|
-| `.goopspec/SPEC.md` | Requirements specification (Draft) |
+| `.goopspec/SPEC.md` | Specification (Draft) |
 | `.goopspec/BLUEPRINT.md` | Wave-based execution plan |
 | `.goopspec/CHRONICLE.md` | Progress tracking |
-| `.goopspec/state.json` | Workflow state |
+| `.goopspec/HANDOFF.md` | Session handoff |
+| State (via goop_state) | Workflow state (phase transitions) |
 
 ## Transitions
 
 | Outcome | Next Step |
 |---------|-----------|
-| Planning complete | `/goop-specify` to lock the specification |
+| Planning complete | `/goop-specify` to lock |
+| Missing discovery | `/goop-discuss` to interview |
 | Unknowns remain | `/goop-research` to investigate |
-| Need to pause | `/goop-pause` to save checkpoint |
-| Existing project | `/goop-status` to see current state |
+| Need to pause | `/goop-pause` to checkpoint |
 
 ## Examples
 
-**Simple Feature:**
+**Gate Passed:**
 ```
-User: /goop-plan add a dark mode toggle
-
-Orchestrator: "Dark mode toggle. A few questions:
-
-1. Should it persist to localStorage across sessions?
-2. Auto-detect system preference (prefers-color-scheme)?
-3. Animate the transition, or instant switch?
+User: /goop-plan
 
-[Uses question tool with options for each]"
+Orchestrator: 
++--------------------------------------------------------+
+|  GOOPSPEC > PLANNING                                    |
++--------------------------------------------------------+
+|  Discovery gate: PASSED                                  |
+|  Creating specification and blueprint...                 |
++--------------------------------------------------------+
 
-... gathers answers ...
-
-Orchestrator: "Got it. Creating specification..."
 [Spawns goop-planner]
-```
 
-**Complex Feature:**
-```
-User: /goop-plan refactor the authentication system
+...
 
-Orchestrator: "Auth refactor is significant. Let me understand the scope.
++--------------------------------------------------------+
+|  GOOPSPEC > PLANNING COMPLETE                           |
++--------------------------------------------------------+
 
-I found 3 auth-related modules in the codebase:
-- src/auth/ (main auth logic)
-- src/middleware/auth.ts (route protection)  
-- src/utils/jwt.ts (token handling)
+**Feature:** Dark Mode Toggle
 
-What's driving this refactor?
+| Document   | Status  |
+|------------|---------|
+| Spec       | Created |
+| Blueprint  | Created |
 
-[Uses question tool]:
-- Security vulnerability found
-- Adding new auth method (OAuth, SSO)
-- Performance issues
-- Technical debt cleanup
-- Other (describe)"
-```
+**3 must-haves** | **2 waves** | **5 tasks**
 
-**Existing Project Detected:**
+## > Next Step
+`/goop-specify`
 ```
-User: /goop-plan new dashboard widgets
 
-Orchestrator: "I found existing project documents:
-- SPEC.md: 'User Authentication System'
-- Status: Execute phase, Wave 2 of 3
-
-[Uses question tool]:
-- Archive auth project and start fresh on widgets
-- Continue auth project (run /goop-status)
-- Overwrite without archiving"
+**Gate Blocked:**
+```
+User: /goop-plan
+
+Orchestrator:
++--------------------------------------------------------+
+|  GOOPSPEC > GATE BLOCKED                                |
++--------------------------------------------------------+
+|  Discovery interview required before planning.          |
+|                                                         |
+|  Run: /goop-discuss                                     |
++--------------------------------------------------------+
 ```
 
 ## Success Criteria
 
-- [ ] Existing documents detected and handled (archive/continue/overwrite)
-- [ ] Memory searched before asking questions
-- [ ] Interview conducted by orchestrator directly (no agent spawn for conversation)
-- [ ] All context checklist categories gathered
-- [ ] User confirmed strategy (create/research/map/explore)
-- [ ] goop-planner spawned with complete interview context
-- [ ] SPEC.md created with must-haves, nice-to-haves, out-of-scope
-- [ ] BLUEPRINT.md created with waves and tasks
-- [ ] CHRONICLE.md initialized
-- [ ] Key decisions saved to memory
+- [ ] Gate check performed (interview_complete + REQUIREMENTS.md)
+- [ ] If gate fails, refused with clear redirect to /goop-discuss
+- [ ] Existing documents handled (archive/continue/overwrite)
+- [ ] goop-planner spawned with full discovery context
+- [ ] SPEC.md created with traceability
+- [ ] BLUEPRINT.md created with spec coverage
+- [ ] 100% must-have coverage achieved
+- [ ] HANDOFF.md generated
 - [ ] User knows next step is `/goop-specify`
+- [ ] Suggested to start new session for fresh context
 
 ## Anti-Patterns
 
 **DON'T:**
-- Spawn an agent to conduct the interview
-- Ask questions you found answers to in memory
-- Skip the archive check when existing docs exist
-- Create documents without user confirming strategy
-- Leave user without clear next steps
-- Rush through questioning to get to document creation
+- Skip the discovery gate check
+- Conduct interview in /goop-plan (that's /goop-discuss)
+- Create documents without traceability
+- Leave user without next steps
+- Skip handoff generation
 
 **DO:**
-- Search memory before every question category
-- Follow conversation threads naturally
-- Challenge vague requirements ("what do you mean by fast?")
-- Save new preferences to memory immediately
-- Present clear "Next Up" section with copy-paste commands
-- Take time to understand - planning is the highest leverage phase
+- Enforce the gate strictly
+- Spawn planner with complete context
+- Verify 100% traceability
+- Generate HANDOFF.md
+- Suggest new session for clean context
+
+---
+
+*Planning Protocol v0.1.4*
+*"Every must-have traces to tasks."*