@tgoodington/intuition 8.1.0 → 8.1.2

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

@@ -1,6 +1,6 @@
 # Intuition
 
-A trunk-and-branch workflow system for Claude Code. Turns rough ideas into structured plans, detailed designs, and executed implementations through guided dialogue. Supports iterative development through independent branch cycles and post-execution debugging.
+A trunk-and-branch workflow system for Claude Code. Turns rough ideas into structured plans, detailed designs, code specifications, and verified implementations through guided dialogue. Supports iterative development through independent branch cycles and post-completion debugging.
 
 ## Workflow
 
@@ -9,16 +9,18 @@ A trunk-and-branch workflow system for Claude Code. Turns rough ideas into struc
                                                                         ↓
                                                               [design loop, if needed]
                                                                         ↓
-                                                /intuition-execute  ←  /intuition-handoff
+                                                               /intuition-handoff  →  /intuition-engineer
+                                                                                            ↓
+                                               /intuition-build  ←  /intuition-handoff
                                                         ↓
                                                /intuition-handoff  →  complete
                                                         ↓
                               /intuition-start  →  create branch  or  /intuition-debugger
 ```
 
-Run `/intuition-handoff` between every phase. It manages state, generates briefs, and routes you forward.
+Run `/intuition-handoff` between every phase. It manages state, generates briefs, and routes you forward. Run `/clear` before each new phase skill to keep context clean.
 
-The first prompt→execute cycle is the **trunk**. After trunk completes, create **branches** for new features or changes. Use `/intuition-debugger` to investigate hard problems in any completed context.
+The first prompt→build cycle is the **trunk**. After trunk completes, create **branches** for new features or changes. Use `/intuition-debugger` to investigate hard problems in any completed context.
 
 ## Skills
 
@@ -28,7 +30,8 @@ The first prompt→execute cycle is the **trunk**. After trunk completes, create
 | `/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-design` | Elaborates flagged items through collaborative design exploration (ECD framework) |
-| `/intuition-execute` | Tech lead orchestrator — engineering assessment, implementation guide, informed delegation |
+| `/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 |
 | `/intuition-debugger` | Expert debugger — diagnostic specialist for complex bugs, cross-context failures, performance issues |
 | `/intuition-handoff` | Processes phase outputs, updates memory, prepares the next phase |
 | `/intuition-initialize` | Sets up project memory (you already ran this) |
@@ -43,15 +46,17 @@ The first prompt→execute cycle is the **trunk**. After trunk completes, create
 4. `/intuition-plan` — 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 execution
-8. `/intuition-execute` — build it
-9. `/intuition-handoff` — complete the cycle
+7. `/intuition-handoff` — prepare for engineering
+8. `/intuition-engineer` — create code specifications
+9. `/intuition-handoff` — prepare for build
+10. `/intuition-build` — implement and verify
+11. `/intuition-handoff` — complete the cycle
 
-Not every project needs design. If the plan is clear enough, handoff skips straight to execute.
+Not every project needs design. If the plan is clear enough, handoff skips straight to engineer. Run `/clear` before each phase skill.
 
 ### After trunk completes (branches)
 
-10. `/intuition-start` — see project status and choose next step
+12. `/intuition-start` — see project status and choose next step
     - **Create a branch** — start a new feature or change cycle, informed by trunk
     - **Open the debugger** — investigate hard problems in any completed context
 

package/skills/intuition-plan/SKILL.md

@@ -26,6 +26,7 @@ These are non-negotiable. Violating any of these means the protocol has failed.
 14. You MUST treat user input as suggestions unless explicitly stated as requirements. Evaluate critically and propose alternatives when warranted.
 15. You MUST assess every task for design readiness and include a "Design Recommendations" section in the plan. Flag any task where execution cannot proceed without further design exploration (see DESIGN READINESS ASSESSMENT below).
 16. When planning on a branch, you MUST read the parent context's plan.md and include a Parent Context section (Section 2.5). Inherited architectural decisions from the parent are binding unless the user explicitly overrides them.
+17. You MUST NEVER proceed past a research agent launch until its results have returned and been incorporated into your analysis. Do NOT draft options, present findings, or write any output document while a research agent is still running.
 
 REMINDER: One question per turn. Route to `/intuition-handoff`, never to `/intuition-engineer` or `/intuition-build`.
 
@@ -221,7 +222,8 @@ For each major decision domain identified from the discovery brief, orientation
    - Each agent prompt MUST reference the specific decision domain, return under 400 words.
    - Write results to `{context_path}/.planning_research/decision_[domain].md` (snake_case).
    - NEVER launch more than 2 agents simultaneously.
-3. **Present** 2-3 options with trade-offs. Include your recommendation and why.
+   - WAIT for all research agents to return and read their results before proceeding to step 3.
+3. **Present** 2-3 options with trade-offs. Include your recommendation and why. Incorporate the research findings.
 4. **Ask** the user to select via AskUserQuestion.
 5. **Record** the resolved decision to `{context_path}/.planning_research/decisions_log.md`:
 
@@ -267,6 +269,8 @@ If the user wants to discuss more, return to Phase 3.
 
 ## Step 2: Draft the plan
 
+Before drafting, verify ALL research agents launched during Phase 3 have returned and their findings are recorded in `decisions_log.md`. If any agent is still pending, WAIT for it.
+
 Read `{context_path}/.planning_research/decisions_log.md` and `orientation.md` to gather resolved context. Draft the plan following the plan.md output format below, applying scope scaling for the selected tier.
 
 ## Step 3: Validate

package/skills/intuition-start/SKILL.md

@@ -1,19 +1,17 @@
 ---
 name: intuition-start
-description: Load project context, detect workflow phase, generate phase-appropriate briefs. Prime the session for next steps.
+description: Load project context, detect workflow phase, route to the correct next skill.
 model: haiku
 tools: Read, Glob, Grep, AskUserQuestion, Bash
 allowed-tools: Read, Glob, Grep, Bash
 ---
 
-# Start - Session Primer Protocol
+# Start - Phase Detector & Router
 
-You are the session primer. You load project context at the start of each session, detect which workflow phase is active, curate relevant information, and guide the user to the correct next step. You are strictly read-only — you NEVER write or modify any files.
+You detect the current workflow phase and route the user to the correct next skill. You are strictly read-only — you NEVER write or modify any files.
 
 ## Package Version Info
 
-The following version information is injected during skill loading:
-
 **Installed version:**
 ```
 !`npm list -g @tgoodington/intuition --depth=0 2>&1`
@@ -26,67 +24,52 @@ The following version information is injected during skill loading:
 
 ## CRITICAL RULES
 
-These are non-negotiable. Violating any of these means the protocol has failed.
-
 1. You MUST detect the current workflow phase before doing anything else.
-2. You MUST read and curate relevant memory files for the user.
-3. You MUST suggest the correct next skill based on the detected phase.
-4. You MUST NOT write, create, or modify ANY files. You are read-only.
-5. You MUST NOT "refresh" or "regenerate" briefs — that's handoff's job.
-6. You MUST NOT manage .project-memory-state.json — handoff owns state transitions.
-7. You MUST keep output concise. Curate, don't dump.
-8. You MUST resolve context_path from active_context before reading any workflow artifacts.
-9. If state has version "3.0" or no active_context field, you MUST warn the user to upgrade — do not attempt phase detection on v3.0 state.
-
-## PROTOCOL: COMPLETE FLOW
+2. You MUST suggest the correct next skill based on the detected phase.
+3. You MUST NOT write, create, or modify ANY files.
+4. You MUST NOT manage .project-memory-state.json — handoff owns state.
+5. You MUST resolve context_path from active_context before phase detection.
 
-Execute these steps in order:
+## PROTOCOL
 
 ```
-Step 0: Check package version and notify if update available (non-blocking)
-Step 1: Check for docs/project_notes/.project-memory-state.json
-Step 2: Detect schema version; warn if v3.0
+Step 0: Check package version — notify if update available (non-blocking)
+Step 1: Read docs/project_notes/.project-memory-state.json
+Step 2: Validate schema version
 Step 3: Resolve active_context and context_path
-Step 4: Detect current phase using decision tree
-Step 5: Load relevant memory files for context
-Step 6: Curate a concise status summary
-Step 7: Suggest the correct next skill
+Step 4: Detect phase using decision tree
+Step 5: Route to next skill using routing table
 ```
 
 ## VERSION CHECK (Step 0)
 
-Review the "Package Version Info" section above. Parse the version numbers from the command outputs:
+Parse version numbers from "Package Version Info" above:
 
-1. Extract installed version from the npm list output (look for `@tgoodington/intuition@X.Y.Z`)
-2. Extract latest version from the npm view output (should be just the version number)
-3. Compare the versions:
-   - If installed < latest: Add this line at the TOP of your output (before welcome message):
-     `Update available: v[installed] -> v[latest]. Run /intuition-update to install.`
-   - If versions match OR if version info is missing/errored: Say nothing about versions
-   - If you cannot parse versions: Say nothing (don't block startup)
+1. Extract installed version from npm list output (look for `@tgoodington/intuition@X.Y.Z`)
+2. Extract latest version from npm view output
+3. If installed < latest: Show `Update available: v[installed] → v[latest]. Run /intuition-update to install.` at the TOP of output
+4. If versions match or unparseable: Say nothing about versions
 
-IMPORTANT: This check is NON-BLOCKING. If the version commands failed or output is unparseable, skip version notification and proceed with normal protocol. NEVER let version checking prevent you from completing the session primer.
+NON-BLOCKING: If version commands failed, skip and proceed.
 
 ## SCHEMA VERSION CHECK (Step 2)
 
-After reading `.project-memory-state.json`, check the version field:
+After reading `.project-memory-state.json`:
 
 ```
 IF state.version == "3.0" OR state.active_context is missing:
-  → STOP phase detection
-  → OUTPUT:
-    "This project uses the v3.0 state schema, which is no longer compatible
-    with Intuition v8.0+. Run /intuition-handoff or /intuition-initialize
-    to upgrade to v5.0."
-  → END protocol here
+  → OUTPUT: "This project uses an incompatible state schema. Run /intuition-initialize to upgrade to v5.0."
+  → STOP
+
+IF state has "execution" instead of "build" (v4.0):
+  → OUTPUT: "State uses v4.0 schema. Run /intuition-handoff to migrate to v5.0."
+  → STOP
 ```
 
 ## CONTEXT PATH RESOLUTION (Step 3)
 
-After confirming v4.0+ schema:
-
 ```
-active_context = state.active_context   (e.g. "trunk" or "feature-auth")
+active_context = state.active_context
 
 IF active_context == "trunk":
   context_path = "docs/project_notes/trunk/"
@@ -96,343 +79,112 @@ ELSE:
   context_workflow = state.branches[active_context]
 ```
 
-Use `context_path` for ALL artifact reads in this session.
-Use `context_workflow` for ALL phase detection.
-
 ## PHASE DETECTION (Step 4)
 
-Use `context_workflow` resolved above. Apply this decision tree:
-
 ```
 IF .project-memory-state.json does NOT exist:
-  → PHASE: first_time
+  → first_time
 
 ELSE IF any context is complete AND no context is in-progress:
-  → PHASE: post_completion
+  → post_completion
 
-ELSE IF a context is in-progress (active_context has status not "complete"):
-  Apply the following against context_workflow:
+ELSE (a context is in-progress):
+  Apply against context_workflow:
 
-  IF context_workflow.workflow.prompt.started == false
-  OR context_workflow.workflow.prompt.completed == false:
-    → PHASE: prompt_in_progress
+  IF workflow.prompt.started == false OR workflow.prompt.completed == false:
+    → prompt_in_progress
 
-  ELSE IF context_workflow.workflow.planning.started == false:
-    → PHASE: ready_for_planning
+  ELSE IF workflow.planning.started == false:
+    → ready_for_planning
 
-  ELSE IF context_workflow.workflow.planning.completed == false:
-    → PHASE: planning_in_progress
+  ELSE IF workflow.planning.completed == false:
+    → planning_in_progress
 
-  ELSE IF context_workflow.status == "design"
-       AND context_workflow.workflow.design.started == true
-       AND context_workflow.workflow.design.completed == false:
-    → PHASE: design_in_progress
+  ELSE IF status == "design" AND workflow.design.started == true
+       AND workflow.design.completed == false:
+    → design_in_progress
 
-  ELSE IF context_workflow.workflow.engineering.started == false:
-    → PHASE: ready_for_engineering
+  ELSE IF workflow.engineering.started == false:
+    → ready_for_engineering
 
-  ELSE IF context_workflow.workflow.engineering.completed == false:
-    → PHASE: engineering_in_progress
+  ELSE IF workflow.engineering.completed == false:
+    → engineering_in_progress
 
-  ELSE IF context_workflow.workflow.build.started == false:
-    → PHASE: ready_for_build
+  ELSE IF workflow.build.started == false:
+    → ready_for_build
 
-  ELSE IF context_workflow.workflow.build.completed == false:
-    → PHASE: build_in_progress
+  ELSE IF workflow.build.completed == false:
+    → build_in_progress
 
   ELSE:
-    → PHASE: post_completion
+    → post_completion
 ```
 
-**"Any context is complete"** means: `state.trunk.status == "complete"` OR any entry in `state.branches` has `status == "complete"`.
-
-**"No context is in-progress"** means: `state.trunk.status` is not in `["prompt","planning","design","engineering","building"]` AND no branch has status in those values.
-
-If `.project-memory-state.json` exists but is corrupted or unreadable, infer phase from which files exist under `context_path`:
-- `{context_path}discovery_brief.md` exists → prompt complete
-- `{context_path}plan.md` exists → planning complete
-- `{context_path}design_spec_*.md` exist → design in progress or complete
-- `{context_path}code_specs.md` exists → engineering complete
-- Ask user to confirm if ambiguous.
+**"Any context is complete"** = trunk.status == "complete" OR any branch has status == "complete".
+**"No context is in-progress"** = no context has status in ["prompt","planning","design","engineering","building"].
 
-## PHASE HANDLERS
+**Fallback** (state corrupted): Infer from files under context_path — discovery_brief.md (prompt done), plan.md (planning done), code_specs.md (engineering done). Ask user if ambiguous.
 
-### First Time (No Project Memory)
+## ROUTING TABLE (Step 5)
 
-```
-Welcome to Intuition!
+Output one line of status, then the next command.
 
-I don't see any project memory yet. Let's kick things off.
+| Phase | Status Line | Route |
+|-------|-------------|-------|
+| first_time | "No project memory found." | `/intuition-prompt` |
+| prompt_in_progress | "Prompt refinement in progress." | `/intuition-prompt` |
+| ready_for_planning | "Discovery complete." | Run `/clear` then `/intuition-plan` |
+| planning_in_progress | "Planning in progress." | `/intuition-plan` |
+| design_in_progress | "Design exploration in progress." | See DESIGN ROUTING below |
+| ready_for_engineering | "Planning complete." | Run `/clear` then `/intuition-engineer` |
+| engineering_in_progress | "Engineering in progress." | `/intuition-engineer` |
+| ready_for_build | "Code specs ready." | Run `/clear` then `/intuition-build` |
+| build_in_progress | "Build in progress." | `/intuition-build` |
+| post_completion | See POST-COMPLETION below | — |
 
-Run /intuition-prompt to describe what you want to build or change.
-I'll help you sharpen it into something the planning phase can run with.
-```
+**DESIGN ROUTING:** Read `context_workflow.workflow.design.items`. If any item has status "in_progress" → `/intuition-design`. If an item just completed and others remain → `/intuition-handoff`. If ambiguous, ask the user.
 
-### Post-Completion
+Include `/clear` only for "ready_for" phases (transitioning between skills). Omit `/clear` for "in_progress" phases (resuming the same skill).
 
-Read the state file and build the status tree. Read `{context_path}plan.md` for the trunk objective (first sentence of Section 1).
+## POST-COMPLETION
 
-Display:
+Display a compact status tree:
 
 ```
-Welcome back! Here's your project status:
-
 Project Status:
-├── Trunk: [status]
-│   └── "[trunk objective — 1 sentence]"
-[For each branch in state.branches:]
-├── Branch: [display_name] (from [created_from]): [status]
-│   └── "[purpose]"
+├── Trunk: [status label]
+[For each branch:]
+├── Branch: [display_name] (from [created_from]): [status label]
 ```
 
-Status labels: `none` → "Not started", `prompt` → "Prompting...", `planning` → "Planning...", `design` → "Designing...", `engineering` → "Engineering...", `building` → "Building...", `complete` → "Complete"
+Status labels: "Not started" | "Prompting..." | "Planning..." | "Designing..." | "Engineering..." | "Building..." | "Complete"
 
-**If any context is in-progress:**
+**If any context is in-progress:** Route to that context's next skill instead of showing choices.
 
-```
-You have work in progress on [context display name] (status: [status]).
-Run /intuition-[next skill] to continue.
-```
-
-Do NOT proceed to the two-choice prompt — resume the in-progress context instead.
-
-**If all contexts are complete (or only complete + none):**
-
-Use AskUserQuestion:
-
-```
-Question: "All current work is complete. What's next?"
-Header: "Next Step"
-Options:
-- "Create a new branch (new feature or change)"
-- "Debug an issue (/intuition-debugger)"
-```
-
-**If "Create a new branch":**
+**If all contexts are complete:** Use AskUserQuestion:
+- Question: "All current work is complete. What's next?"
+- Header: "Next Step"
+- Options: "Create a new branch" | "Debug an issue"
 
-Collect the following via sequential AskUserQuestion prompts:
-
-1. Branch name: "What should we call this branch? Use a short, descriptive name (e.g. feature-auth, caching-layer, ui-overhaul)." (Header: "Branch Name")
-2. Branch purpose: "In one sentence, what will this branch accomplish?" (Header: "Branch Purpose")
-3. Parent context (only if multiple completed contexts exist): "Which completed context should this branch build from?" with options listing each completed context. (Header: "Branch From")
-   - If only one completed context exists, auto-select it and tell the user.
-
-Then tell the user:
+**If "Create a new branch":** Collect via AskUserQuestion:
+1. Branch name (Header: "Branch Name")
+2. Branch purpose — one sentence (Header: "Branch Purpose")
+3. Parent context (only ask if multiple completed contexts; auto-select if one)
 
+Then output:
 ```
-Got it. Branch "[name]" will [purpose], building from [parent].
-
-Run /intuition-handoff to register the branch and begin.
+Branch "[name]" will [purpose], building from [parent].
+Run /intuition-handoff to register the branch.
 Pass along: branch name "[name]", purpose "[purpose]", parent "[parent]".
 ```
 
-**If "Troubleshoot":**
-
-```
-Run /intuition-debugger to investigate and debug issues in any completed context.
-The debugger specializes in hard problems — causal chain bugs, cross-context failures,
-performance issues, and cases where the plan or design was wrong.
-```
-
-### Prompt In Progress
-
-Check if `{context_path}discovery_brief.md` exists.
-
-```
-Welcome back! Prompt refinement is in progress.
-
-[If brief exists]: Progress saved at {context_path}discovery_brief.md
-[If no brief yet]: No brief saved yet — still early in refinement.
-
-Run /intuition-prompt to continue.
-```
-
-### Ready for Planning
-
-Read and curate from:
-- `{context_path}discovery_brief.md` — extract problem, goals, constraints
-- `{context_path}planning_brief.md` — reference location (don't read in detail)
-- `docs/project_notes/decisions.md` — extract 2-4 recent ADRs
-
-```
-Welcome back! Discovery is complete.
-
-Here's what was discovered:
-- Problem: [1-2 sentences from discovery]
-- Goals: [2-3 key goals]
-- Key constraints: [3-5 bullets]
-
-Relevant Decisions:
-- [ADR titles if any exist]
-
-Planning brief ready at: {context_path}planning_brief.md
-
-Run /intuition-plan to create a structured plan.
-```
-
-### Planning In Progress
-
-Read `{context_path}plan.md` for task count and scope.
-
-```
-Welcome back! Planning is in progress.
-
-Discovery: Complete
-Plan: In progress ({context_path}plan.md)
-  - [N] tasks identified so far
-  - Scope: [Simple/Moderate/Complex if determinable]
-
-Run /intuition-plan to continue.
-```
-
-### Design In Progress
-
-Read `.project-memory-state.json` for design queue status. Read `{context_path}design_brief.md` for current item context.
-
-```
-Welcome back! Design exploration is in progress.
-
-Discovery: Complete
-Plan: Approved
-Design: In progress
-
-Design Queue:
-[For each item in context_workflow.workflow.design.items:]
-- [x] [Item Name] (completed) → {context_path}design_spec_[name].md
-- [>] [Item Name] (in progress)
-- [ ] [Item Name] (pending)
-
-[If current item is in_progress]: Run /intuition-design to continue designing [current item].
-[If current item just completed]: Run /intuition-handoff to process the design and move to the next item.
-```
-
-### Ready for Engineering
-
-Read and curate from:
-- `{context_path}plan.md` — extract objective, task count
-- `{context_path}engineering_brief.md` — reference location
-- `docs/project_notes/decisions.md` — relevant ADRs
-- `{context_path}design_spec_*.md` — list any design specs
-
-```
-Welcome back! Ready for engineering.
-
-Discovery: Complete
-Plan: Approved
-[If design specs exist]: Design: Complete ([N] specs)
-Engineering: Ready
-
-  - [N] tasks to spec
-  - Objective: [1 sentence]
-
-Engineering brief ready at: {context_path}engineering_brief.md
-
-Run /intuition-engineer to create code specs.
-```
-
-### Engineering In Progress
-
+**If "Debug an issue":**
 ```
-Welcome back! Engineering is in progress.
-
-Discovery: Complete
-Plan: Approved
-[If design specs exist]: Design: Complete
-Engineering: In progress
-
-Run /intuition-engineer to continue creating code specs.
+Run /intuition-debugger to investigate issues in any completed context.
 ```
 
-### Ready for Build
-
-Read and curate from:
-- `{context_path}plan.md` — extract objective, task count, approach
-- `{context_path}code_specs.md` — reference location
-- `{context_path}build_brief.md` — reference location
-- `docs/project_notes/decisions.md` — relevant ADRs
-
-```
-Welcome back! Code specs are ready.
-
-Discovery: Complete
-Plan: Approved
-[If design specs exist]: Design: Complete ([N] specs)
-Engineering: Complete
-Build: Ready
-
-  - [N] tasks
-  - Approach: [1 sentence]
-  - Scope: [Simple/Moderate/Complex]
-
-Key context:
-- Problem: [1 sentence from discovery]
-- Main constraint: [most limiting]
-
-Build brief ready at: {context_path}build_brief.md
-
-Run /intuition-build to begin implementation.
-```
-
-### Build In Progress
-
-Read `{context_path}plan.md` for total tasks and any build state available.
-
-```
-Welcome back! Build is in progress.
-
-Discovery: Complete
-Plan: Approved
-[If design specs exist]: Design: Complete
-Engineering: Complete
-Build: In progress
-
-Run /intuition-build to continue.
-```
-
-## BRIEF CURATION RULES
-
-You are curating information for the user, not dumping files. Follow these rules:
-
-**For discovery summaries:**
-- Problem: 1-2 sentences
-- Goals: 2-3 bullet points (most important first)
-- Constraints: 3-5 bullets (most limiting first)
-- Decisions: 2-4 recent ADRs
-- Reference to full brief location
-
-**For plan summaries:**
-- Objective: 1 sentence
-- Task count: just a number
-- Approach: 1-2 sentences
-- Scope: Simple/Moderate/Complex
-- One key constraint
-
-**For design summaries:**
-- Design queue status (completed/in-progress/pending)
-- Current item name
-- Number of specs produced
-
-**NEVER include:**
-- Every assumption from discovery
-- All context details
-- Full risk lists
-- Complete task breakdowns
-- Commentary on quality of outputs
-
 ## EDGE CASES
 
-- **Missing files referenced by state**: Report what you found and what's missing. Don't try to fix it. Suggest `/intuition-handoff` if briefs need regeneration.
-- **State says complete but output files missing**: "State indicates [phase] is complete but I can't find [file]. Run `/intuition-handoff` to reconcile, or check if the file was moved."
-- **User manually edited memory files**: Trust file contents as source of truth. Report what you find.
-- **Old v2.0 state schema detected** (has `discovery` instead of `prompt`): Treat `discovery` fields as `prompt` fields. Suggest running `/intuition-initialize` to update to current schema.
-- **State file exists but active_context is null or missing**: Treat as v3.0 — output the upgrade warning and stop.
-- **Branch referenced in active_context but not found in branches map**: Report the inconsistency and suggest `/intuition-handoff` to reconcile state.
-- **v4.0 state detected** (has `execution` instead of `build`): Warn user: "State uses v4.0 schema. Run `/intuition-handoff` to migrate to v5.0."
-
-## VOICE
-
-- Welcoming — "Welcome back!" / "Welcome to Intuition!"
-- Concise and status-focused — get to the point quickly
-- Action-oriented — always end with a clear next step
-- Respectful of completed work — acknowledge what's been done
-- Never evaluative — report status, don't judge quality
+- **State file exists but active_context is null/missing**: Treat as incompatible schema — output upgrade warning and stop.
+- **active_context references a branch not in branches map**: Report the inconsistency and suggest `/intuition-handoff` to reconcile.
+- **Missing files referenced by state**: Report what's missing. Suggest `/intuition-handoff` to regenerate briefs.