@tgoodington/intuition 9.2.0 → 9.2.1

package/skills/intuition-initialize/references/agents_template.md

@@ -1,118 +1,118 @@
-# Multi-Agent System & Project Memory
-
-## Overview
-
-This project uses a multi-agent system coordinated by Intuition (`@tgoodington/intuition`), a Claude Code skill system. Twelve specialized skills handle prompt refinement, planning, design exploration, code engineering, and build execution, with memory maintained in `docs/project_notes/` for consistency across sessions.
-
-## Workflow Skills
-
-### Core Workflow (run in sequence with handoff between each)
-
-| Skill | Model | What it does |
-|-------|-------|-------------|
-| `/intuition-prompt` | opus | Transforms a rough vision into a planning-ready brief through focused iterative refinement |
-| `/intuition-plan` | opus | Strategic architect — maps stakeholders, explores components, evaluates options, creates executable blueprint |
-| `/intuition-design` | opus | Elaborates flagged plan items through ECD framework (Elements, Connections, Dynamics) |
-| `/intuition-engineer` | opus | Creates code-level specifications through codebase research and interactive dialogue → `code_specs.md` |
-| `/intuition-build` | sonnet | Delegates implementation to subagents, verifies outputs against code specs and acceptance criteria |
-
-### Infrastructure
-
-| Skill | Model | What it does |
-|-------|-------|-------------|
-| `/intuition-start` | haiku | Loads project context, detects workflow phase, routes to correct next skill |
-| `/intuition-handoff` | haiku | Processes phase outputs, updates memory, generates briefs for the next phase |
-| `/intuition-initialize` | haiku | Sets up project memory infrastructure (run once per project) |
-| `/intuition-update` | haiku | Package update manager |
-
-### Advisory
-
-| Skill | Model | What it does |
-|-------|-------|-------------|
-| `/intuition-debugger` | opus | Expert debugger — 5 diagnostic categories, causal chain analysis, post-completion only |
-| `/intuition-agent-advisor` | opus | Expert advisor on building custom Claude Code agents |
-| `/intuition-skill-guide` | opus | Expert advisor on building custom Claude Code skills |
-
-## Model Strategy
-
-- **opus** — Complex multi-step reasoning: prompt refinement, planning, design exploration, code engineering, debugging, advisory
-- **sonnet** — Project management and delegation: build manager, broad research subagents
-- **haiku** — Focused simple tasks: start, handoff, state updates, narrow research subagents
-
-## Workflow
-
-### Trunk (first cycle)
-
-```
-/intuition-prompt → handoff → /intuition-plan → handoff →
-  [/intuition-design loop] → handoff → /intuition-engineer → handoff →
-  /intuition-build → handoff → complete
-```
-
-Each handoff transition:
-1. Reads the previous phase's output
-2. Updates shared memory files
-3. Generates a fresh brief for the next phase
-4. Updates `.project-memory-state.json`
-5. Routes to the next skill (with `/clear` between phases)
-
-### Branches (subsequent cycles)
-
-After trunk completes, run `/intuition-start` to:
-- **Create a branch** — new prompt→build cycle informed by trunk context
-- **Open the debugger** — investigate hard problems in any completed context
-
-Branches follow the same 5-phase workflow but read parent context for continuity.
-
-### Design Loop (optional)
-
-The plan flags tasks requiring design exploration (Section 6.5). If design items exist:
-1. Handoff generates a design brief for the first item
-2. `/intuition-design` elaborates it using the ECD framework
-3. Handoff checks for remaining items → loops back or advances to engineer
-
-### Engineer → Build Split
-
-- **Engineer** (opus, interactive) determines the code-level HOW: reads codebase via research subagents, discusses decisions with you, produces `code_specs.md`
-- **Build** (sonnet, PM) implements against specs: delegates to Code Writer subagents, verifies with Code Reviewer, runs mandatory Security Expert review, produces `build_report.md`
-- Build makes NO engineering decisions — it matches output to specs
-
-## Build Sub-Agents
-
-The build phase delegates to these task-based subagents via the Task tool:
-
-| Sub-Agent | Model | Purpose |
-|-----------|-------|---------|
-| Code Writer | sonnet | Implements features and fixes per code specs |
-| Code Reviewer | sonnet | Reviews quality, maintainability, adherence to specs |
-| Security Expert | sonnet | Scans for vulnerabilities (mandatory before completion) |
-
-## Project Memory
-
-**Memory Files** (`docs/project_notes/`):
-- `bugs.md` — Bug log with solutions and prevention notes
-- `decisions.md` — Architectural Decision Records (ADRs)
-- `key_facts.md` — Project configuration, constants, URLs
-- `issues.md` — Work log with ticket references
-
-**Phase Output Files** (in `{context_path}/`):
-- `planning_brief.md` — Brief for planning (created by handoff)
-- `plan.md` — Structured plan with tasks, design recommendations
-- `design_brief.md` — Brief for current design item (created/updated by handoff)
-- `engineering_brief.md` — Brief for engineering (created by handoff)
-- `code_specs.md` — Code-level specifications (created by engineer)
-- `build_brief.md` — Brief for build (created by handoff)
-- `build_report.md` — Task outcomes, files modified (created by build)
-
-**How Skills Use Memory:**
-- Check `decisions.md` before proposing architectural changes
-- Search `bugs.md` for similar issues before debugging
-- Reference `key_facts.md` for project configuration
-- Log completed work in `issues.md`
-
-## Coordination
-
-- All workflow skills route to `/intuition-handoff` between phases
-- Handoff is the ONLY skill that writes to `.project-memory-state.json`
-- `/clear` runs between phases to keep context clean (each skill reads from disk)
-- State tracks trunk, branches, and active context with per-context workflow pipelines
+# Multi-Agent System & Project Memory
+
+## Overview
+
+This project uses a multi-agent system coordinated by Intuition (`@tgoodington/intuition`), a Claude Code skill system. Twelve specialized skills handle prompt refinement, planning, design exploration, code engineering, and build execution, with memory maintained in `docs/project_notes/` for consistency across sessions.
+
+## Workflow Skills
+
+### Core Workflow (run in sequence with handoff between each)
+
+| Skill | Model | What it does |
+|-------|-------|-------------|
+| `/intuition-prompt` | opus | Transforms a rough vision into a planning-ready brief through focused iterative refinement |
+| `/intuition-outline` | opus | Strategic architect — maps stakeholders, explores components, evaluates options, creates executable blueprint |
+| `/intuition-design` | opus | Elaborates flagged plan items through ECD framework (Elements, Connections, Dynamics) |
+| `/intuition-engineer` | opus | Creates code-level specifications through codebase research and interactive dialogue → `code_specs.md` |
+| `/intuition-build` | sonnet | Delegates implementation to subagents, verifies outputs against code specs and acceptance criteria |
+
+### Infrastructure
+
+| Skill | Model | What it does |
+|-------|-------|-------------|
+| `/intuition-start` | haiku | Loads project context, detects workflow phase, routes to correct next skill |
+| `/intuition-handoff` | haiku | Processes phase outputs, updates memory, generates briefs for the next phase |
+| `/intuition-initialize` | haiku | Sets up project memory infrastructure (run once per project) |
+| `/intuition-update` | haiku | Package update manager |
+
+### Advisory
+
+| Skill | Model | What it does |
+|-------|-------|-------------|
+| `/intuition-debugger` | opus | Expert debugger — 5 diagnostic categories, causal chain analysis, post-completion only |
+| `/intuition-agent-advisor` | opus | Expert advisor on building custom Claude Code agents |
+| `/intuition-skill-guide` | opus | Expert advisor on building custom Claude Code skills |
+
+## Model Strategy
+
+- **opus** — Complex multi-step reasoning: prompt refinement, planning, design exploration, code engineering, debugging, advisory
+- **sonnet** — Project management and delegation: build manager, broad research subagents
+- **haiku** — Focused simple tasks: start, handoff, state updates, narrow research subagents
+
+## Workflow
+
+### Trunk (first cycle)
+
+```
+/intuition-prompt → handoff → /intuition-outline → handoff →
+  [/intuition-design loop] → handoff → /intuition-engineer → handoff →
+  /intuition-build → handoff → complete
+```
+
+Each handoff transition:
+1. Reads the previous phase's output
+2. Updates shared memory files
+3. Generates a fresh brief for the next phase
+4. Updates `.project-memory-state.json`
+5. Routes to the next skill (with `/clear` between phases)
+
+### Branches (subsequent cycles)
+
+After trunk completes, run `/intuition-start` to:
+- **Create a branch** — new prompt→build cycle informed by trunk context
+- **Open the debugger** — investigate hard problems in any completed context
+
+Branches follow the same 5-phase workflow but read parent context for continuity.
+
+### Design Loop (optional)
+
+The plan flags tasks requiring design exploration (Section 6.5). If design items exist:
+1. Handoff generates a design brief for the first item
+2. `/intuition-design` elaborates it using the ECD framework
+3. Handoff checks for remaining items → loops back or advances to engineer
+
+### Engineer → Build Split
+
+- **Engineer** (opus, interactive) determines the code-level HOW: reads codebase via research subagents, discusses decisions with you, produces `code_specs.md`
+- **Build** (sonnet, PM) implements against specs: delegates to Code Writer subagents, verifies with Code Reviewer, runs mandatory Security Expert review, produces `build_report.md`
+- Build makes NO engineering decisions — it matches output to specs
+
+## Build Sub-Agents
+
+The build phase delegates to these task-based subagents via the Task tool:
+
+| Sub-Agent | Model | Purpose |
+|-----------|-------|---------|
+| Code Writer | sonnet | Implements features and fixes per code specs |
+| Code Reviewer | sonnet | Reviews quality, maintainability, adherence to specs |
+| Security Expert | sonnet | Scans for vulnerabilities (mandatory before completion) |
+
+## Project Memory
+
+**Memory Files** (`docs/project_notes/`):
+- `bugs.md` — Bug log with solutions and prevention notes
+- `decisions.md` — Architectural Decision Records (ADRs)
+- `key_facts.md` — Project configuration, constants, URLs
+- `issues.md` — Work log with ticket references
+
+**Phase Output Files** (in `{context_path}/`):
+- `outline_brief.md` — Brief for outline (created by handoff)
+- `outline.md` — Structured outline with tasks, design recommendations
+- `design_brief.md` — Brief for current design item (created/updated by handoff)
+- `engineering_brief.md` — Brief for engineering (created by handoff)
+- `code_specs.md` — Code-level specifications (created by engineer)
+- `build_brief.md` — Brief for build (created by handoff)
+- `build_report.md` — Task outcomes, files modified (created by build)
+
+**How Skills Use Memory:**
+- Check `decisions.md` before proposing architectural changes
+- Search `bugs.md` for similar issues before debugging
+- Reference `key_facts.md` for project configuration
+- Log completed work in `issues.md`
+
+## Coordination
+
+- All workflow skills route to `/intuition-handoff` between phases
+- Handoff is the ONLY skill that writes to `.project-memory-state.json`
+- `/clear` runs between phases to keep context clean (each skill reads from disk)
+- State tracks trunk, branches, and active context with per-context workflow pipelines

package/skills/intuition-initialize/references/claude_template.md

@@ -1,134 +1,134 @@
-## Project Workflow and Memory System
-
-This project uses a five-phase workflow coordinated by the Intuition system, with institutional knowledge maintained in `docs/project_notes/` for consistency across sessions.
-
-### Workflow Model
-
-The Intuition workflow uses a trunk-and-branch model:
-- **Trunk**: The first prompt→plan→design→engineer→build cycle. Represents the core vision.
-- **Branches**: Subsequent cycles that build on, extend, or diverge from trunk or other branches.
-- **Debugger**: Post-completion diagnostic specialist for hard problems.
-
-All phases: `/intuition-prompt` → `/intuition-handoff` → `/intuition-plan` → `/intuition-handoff` →
-`[/intuition-design loop]` → `/intuition-handoff` → `/intuition-engineer` → `/intuition-handoff` →
-`/intuition-build` → `/intuition-handoff` → complete
-
-After completion: `/intuition-start` to create branches or `/intuition-debugger` to debug issues.
-
-### Workflow Phases
-
-The project follows a structured workflow with handoff transitions between phases:
-
-**Prompt** — `/intuition-prompt`
-- Transforms a rough vision into a precise, planning-ready brief
-- Framework: Capture → Refine → Reflect → Confirm
-- Output: Planning-ready brief (processed by Handoff into `planning_brief.md`)
-
-**Handoff** — `/intuition-handoff`
-- Processes phase outputs, updates memory files, generates brief for next phase
-- Runs between every phase transition
-- Manages the design loop (item-by-item design cycles)
-- ONLY component that writes to `.project-memory-state.json`
-
-**Planning** — `/intuition-plan`
-- Strategic synthesis and structured execution planning
-- Researches codebase, identifies patterns, creates detailed plan
-- Flags tasks requiring design exploration with rationale
-- Output: `plan.md` with tasks, dependencies, risks, design recommendations
-
-**Design** — `/intuition-design`
-- Detailed design exploration for flagged plan items
-- Framework: ECD (Elements, Connections, Dynamics)
-- Domain-agnostic: works for code, world building, UI, documents, or any creative/structural work
-- Runs once per flagged item in a loop managed by handoff
-- Output: Design specifications per item
-
-**Engineering** — `/intuition-engineer`
-- Creates code-level specifications through codebase research and interactive dialogue
-- Research subagents read codebase, engineer discusses decisions with user
-- Output: `code_specs.md` — determines the code-level HOW for every task
-
-**Build** — `/intuition-build`
-- Delegates implementation to subagents, verifies against code specs and acceptance criteria
-- Mandatory security review before completion
-- Makes NO engineering decisions — matches output to specs
-- Output: `build_report.md` — task outcomes, files modified, deviations from specs
-
-**Session Primer** — `/intuition-start`
-- Loads project context, detects workflow phase, suggests next step
-- Run at the start of any session to get oriented
-
-**Recommended Flow**: Prompt → Handoff → Plan → Handoff → [Design Loop] → Handoff → Engineer → Handoff → Build → Handoff → complete
-
-Run `/clear` before each phase skill. After completion, run `/intuition-start` to create a branch or invoke `/intuition-debugger` to debug issues.
-
-### Memory Files
-
-**Core Memory Files** (initialized at setup):
-- **bugs.md** — Bug log with dates, solutions, and prevention notes
-- **decisions.md** — Architectural Decision Records (ADRs) with context and trade-offs
-- **key_facts.md** — Project configuration, credentials, ports, important URLs
-- **issues.md** — Work log with ticket IDs, descriptions, and URLs
-- **.project-memory-state.json** — Workflow phase tracking and session state
-
-**Phase Output Files** (created during workflow, in `{context_path}/`):
-- **planning_brief.md** — Brief for planning phase (created by Handoff)
-- **plan.md** — Structured project plan with design recommendations
-- **design_brief.md** — Brief for current design item (created/updated by Handoff)
-- **engineering_brief.md** — Brief for engineering phase (created by Handoff)
-- **code_specs.md** — Code-level specifications (created by Engineer)
-- **build_brief.md** — Brief for build phase (created by Handoff)
-- **build_report.md** — Task outcomes and files modified (created by Build)
-
-### Memory-Aware Protocols
-
-**Before proposing architectural changes:**
-- Check `docs/project_notes/decisions.md` for existing decisions
-- Verify the proposed approach doesn't conflict with past choices
-- If it does conflict, acknowledge the existing decision and explain why a change is warranted
-
-**When encountering errors or bugs:**
-- Search `docs/project_notes/bugs.md` for similar issues
-- Apply known solutions if found
-- Document new bugs and solutions when resolved
-
-**When looking up project configuration:**
-- Check `docs/project_notes/key_facts.md` for credentials, ports, URLs, service accounts
-- Prefer documented facts over assumptions
-
-**When completing work on tickets:**
-- Log completed work in `docs/project_notes/issues.md`
-- Include ticket ID, date, brief description, and URL
-
-### Style Guidelines for Memory Files
-
-- Prefer bullet lists over tables for simplicity
-- Keep entries concise (1-3 lines for descriptions)
-- Always include dates for temporal context
-- Include URLs for tickets, documentation, monitoring dashboards
-
-### Smart Skill Suggestions
-
-**When prompt refinement is complete:**
-- "Prompt refinement looks complete! Use `/intuition-handoff` to process insights and prepare for planning."
-
-**When user suggests planning work:**
-- "This sounds like a good candidate for planning. Use `/intuition-handoff` to process the brief, then `/intuition-plan` to develop a structured approach."
-
-**When plan is ready and has design items:**
-- "The plan looks ready! Use `/intuition-handoff` to review design recommendations and start the design loop."
-
-**When design items are complete:**
-- "All design specs are done! Use `/intuition-handoff` to prepare the engineering brief."
-
-**When user is ready to engineer:**
-- "Engineering brief is ready! Use `/intuition-engineer` to create code specifications."
-
-**When engineering is complete:**
-- "Code specs are ready! Use `/intuition-handoff` to prepare the build brief."
-
-**When user is ready to build:**
-- "Build brief is ready! Use `/intuition-build` to kick off implementation."
-
-**When build is complete:**
-- "Workflow cycle complete! Use `/intuition-start` to create a branch for new work, or `/intuition-debugger` to debug any issues."
+## Project Workflow and Memory System
+
+This project uses a five-phase workflow coordinated by the Intuition system, with institutional knowledge maintained in `docs/project_notes/` for consistency across sessions.
+
+### Workflow Model
+
+The Intuition workflow uses a trunk-and-branch model:
+- **Trunk**: The first prompt→plan→design→engineer→build cycle. Represents the core vision.
+- **Branches**: Subsequent cycles that build on, extend, or diverge from trunk or other branches.
+- **Debugger**: Post-completion diagnostic specialist for hard problems.
+
+All phases: `/intuition-prompt` → `/intuition-handoff` → `/intuition-outline` → `/intuition-handoff` →
+`[/intuition-design loop]` → `/intuition-handoff` → `/intuition-engineer` → `/intuition-handoff` →
+`/intuition-build` → `/intuition-handoff` → complete
+
+After completion: `/intuition-start` to create branches or `/intuition-debugger` to debug issues.
+
+### Workflow Phases
+
+The project follows a structured workflow with handoff transitions between phases:
+
+**Prompt** — `/intuition-prompt`
+- Transforms a rough vision into a precise, planning-ready brief
+- Framework: Capture → Refine → Reflect → Confirm
+- Output: Planning-ready brief (processed by Handoff into `outline_brief.md`)
+
+**Handoff** — `/intuition-handoff`
+- Processes phase outputs, updates memory files, generates brief for next phase
+- Runs between every phase transition
+- Manages the design loop (item-by-item design cycles)
+- ONLY component that writes to `.project-memory-state.json`
+
+**Outline** — `/intuition-outline`
+- Strategic synthesis and structured execution planning
+- Researches codebase, identifies patterns, creates detailed plan
+- Flags tasks requiring design exploration with rationale
+- Output: `outline.md` with tasks, dependencies, risks, design recommendations
+
+**Design** — `/intuition-design`
+- Detailed design exploration for flagged plan items
+- Framework: ECD (Elements, Connections, Dynamics)
+- Domain-agnostic: works for code, world building, UI, documents, or any creative/structural work
+- Runs once per flagged item in a loop managed by handoff
+- Output: Design specifications per item
+
+**Engineering** — `/intuition-engineer`
+- Creates code-level specifications through codebase research and interactive dialogue
+- Research subagents read codebase, engineer discusses decisions with user
+- Output: `code_specs.md` — determines the code-level HOW for every task
+
+**Build** — `/intuition-build`
+- Delegates implementation to subagents, verifies against code specs and acceptance criteria
+- Mandatory security review before completion
+- Makes NO engineering decisions — matches output to specs
+- Output: `build_report.md` — task outcomes, files modified, deviations from specs
+
+**Session Primer** — `/intuition-start`
+- Loads project context, detects workflow phase, suggests next step
+- Run at the start of any session to get oriented
+
+**Recommended Flow**: Prompt → Handoff → Plan → Handoff → [Design Loop] → Handoff → Engineer → Handoff → Build → Handoff → complete
+
+Run `/clear` before each phase skill. After completion, run `/intuition-start` to create a branch or invoke `/intuition-debugger` to debug issues.
+
+### Memory Files
+
+**Core Memory Files** (initialized at setup):
+- **bugs.md** — Bug log with dates, solutions, and prevention notes
+- **decisions.md** — Architectural Decision Records (ADRs) with context and trade-offs
+- **key_facts.md** — Project configuration, credentials, ports, important URLs
+- **issues.md** — Work log with ticket IDs, descriptions, and URLs
+- **.project-memory-state.json** — Workflow phase tracking and session state
+
+**Phase Output Files** (created during workflow, in `{context_path}/`):
+- **outline_brief.md** — Brief for outline phase (created by Handoff)
+- **outline.md** — Structured project outline with design recommendations
+- **design_brief.md** — Brief for current design item (created/updated by Handoff)
+- **engineering_brief.md** — Brief for engineering phase (created by Handoff)
+- **code_specs.md** — Code-level specifications (created by Engineer)
+- **build_brief.md** — Brief for build phase (created by Handoff)
+- **build_report.md** — Task outcomes and files modified (created by Build)
+
+### Memory-Aware Protocols
+
+**Before proposing architectural changes:**
+- Check `docs/project_notes/decisions.md` for existing decisions
+- Verify the proposed approach doesn't conflict with past choices
+- If it does conflict, acknowledge the existing decision and explain why a change is warranted
+
+**When encountering errors or bugs:**
+- Search `docs/project_notes/bugs.md` for similar issues
+- Apply known solutions if found
+- Document new bugs and solutions when resolved
+
+**When looking up project configuration:**
+- Check `docs/project_notes/key_facts.md` for credentials, ports, URLs, service accounts
+- Prefer documented facts over assumptions
+
+**When completing work on tickets:**
+- Log completed work in `docs/project_notes/issues.md`
+- Include ticket ID, date, brief description, and URL
+
+### Style Guidelines for Memory Files
+
+- Prefer bullet lists over tables for simplicity
+- Keep entries concise (1-3 lines for descriptions)
+- Always include dates for temporal context
+- Include URLs for tickets, documentation, monitoring dashboards
+
+### Smart Skill Suggestions
+
+**When prompt refinement is complete:**
+- "Prompt refinement looks complete! Use `/intuition-handoff` to process insights and prepare for outline."
+
+**When user suggests outline work:**
+- "This sounds like a good candidate for planning. Use `/intuition-handoff` to process the brief, then `/intuition-outline` to develop a structured approach."
+
+**When plan is ready and has design items:**
+- "The plan looks ready! Use `/intuition-handoff` to review design recommendations and start the design loop."
+
+**When design items are complete:**
+- "All design specs are done! Use `/intuition-handoff` to prepare the engineering brief."
+
+**When user is ready to engineer:**
+- "Engineering brief is ready! Use `/intuition-engineer` to create code specifications."
+
+**When engineering is complete:**
+- "Code specs are ready! Use `/intuition-handoff` to prepare the build brief."
+
+**When user is ready to build:**
+- "Build brief is ready! Use `/intuition-build` to kick off implementation."
+
+**When build is complete:**
+- "Workflow cycle complete! Use `/intuition-start` to create a branch for new work, or `/intuition-debugger` to debug any issues."

package/skills/intuition-initialize/references/intuition_readme_template.md

@@ -5,7 +5,7 @@ A trunk-and-branch workflow system for Claude Code. Turns rough ideas into struc
 ## Workflow
 
 ```
-/intuition-prompt  →  /intuition-handoff  →  /intuition-plan  →  /intuition-handoff
+/intuition-prompt  →  /intuition-handoff  →  /intuition-outline  →  /intuition-handoff
                                                                         ↓
                                                               [design loop, if needed]
                                                                         ↓
@@ -28,7 +28,7 @@ The first prompt→build cycle is the **trunk**. After trunk completes, create *
 |-------|-------------|
 | `/intuition-start` | Detects where you left off, shows project status, routes to next step or branch creation |
 | `/intuition-prompt` | Sharpens a rough idea into a planning-ready brief through focused Q&A |
-| `/intuition-plan` | Builds a strategic blueprint with tasks, decisions, and design flags |
+| `/intuition-outline` | Builds a strategic blueprint with tasks, decisions, and design flags |
 | `/intuition-design` | Elaborates flagged items through collaborative design exploration (ECD framework) |
 | `/intuition-engineer` | Creates code-level specifications through codebase research and interactive dialogue |
 | `/intuition-build` | Delegates implementation to subagents, verifies against code specs and acceptance criteria |
@@ -42,8 +42,8 @@ The first prompt→build cycle is the **trunk**. After trunk completes, create *
 
 1. `/intuition-start` — see where you are
 2. `/intuition-prompt` — describe what you want to build
-3. `/intuition-handoff` — process and move to planning
-4. `/intuition-plan` — create the blueprint
+3. `/intuition-handoff` — process and move to outline
+4. `/intuition-outline` — create the blueprint
 5. `/intuition-handoff` — review design flags, confirm items
 6. `/intuition-design` — elaborate each flagged item (repeat with handoff between)
 7. `/intuition-handoff` — prepare for engineering

package/skills/intuition-initialize/references/state_template.json

@@ -1,6 +1,6 @@
 {
   "initialized": true,
-  "version": "7.0",
+  "version": "8.0",
   "active_context": "trunk",
   "trunk": {
     "status": "none",
@@ -12,7 +12,7 @@
         "completed_at": null,
         "output_files": []
       },
-      "planning": {
+      "outline": {
         "started": false,
         "completed": false,
         "completed_at": null,