@tgoodington/intuition 9.5.0 → 10.1.0

package/README.md

@@ -15,11 +15,10 @@ This installs 12 skills globally to `~/.claude/skills/`. Verify by typing `/` in
 
 ## Workflow
 
-Five phases with handoff transitions between each:
+Two workflow modes:
 
-```
-prompt → outline → [design] → engineer → build
-```
+**v9 (current):** `prompt → outline → assemble → detail → build → test`
+**v8 (legacy):** `prompt → outline → build` (with handoff transitions)
 
 The first cycle is the **trunk**. After completion, create **branches** for new features or changes.
 
@@ -29,18 +28,14 @@ The first cycle is the **trunk**. After completion, create **branches** for new
 /intuition-initialize          # Set up project memory (once per project)
 /intuition-start               # Check status, get routed to next step
 /intuition-prompt              # Describe what you want to build
-/intuition-handoff             # Process → move to outlining
 /intuition-outline             # Create the blueprint
-/intuition-handoff             # Review design flags
-/intuition-design              # Elaborate flagged items (if any)
-/intuition-handoff             # Prepare for engineering
-/intuition-engineer            # Create code specifications
-/intuition-handoff             # Prepare for build
+/intuition-assemble            # Match tasks to domain specialists
+/intuition-detail              # Specialists produce blueprints
 /intuition-build               # Implement and verify
-/intuition-handoff             # Complete the cycle
+/intuition-test                # Quality gate
 ```
 
-Run `/clear` before each phase skill to keep context clean. Not every project needs design — if the outline is clear enough, handoff skips straight to engineer.
+Run `/clear` before each phase skill to keep context clean.
 
 ## Skills
 
@@ -49,20 +44,28 @@ Run `/clear` before each phase skill to keep context clean. Not every project ne
 | Skill | Model | Purpose |
 |-------|-------|---------|
 | `/intuition-prompt` | opus | Refines a rough idea into an outline-ready brief |
-| `/intuition-outline` | opus | Strategic blueprint with tasks, dependencies, design flags |
-| `/intuition-design` | opus | ECD framework design exploration for flagged items |
-| `/intuition-engineer` | opus | Code-level specs through research + interactive dialogue |
-| `/intuition-build` | sonnet | Delegates implementation, verifies against specs |
+| `/intuition-outline` | opus | Strategic blueprint with tasks, dependencies, depth assessment |
+| `/intuition-assemble` | sonnet | Matches tasks to domain specialists and producers |
+| `/intuition-detail` | opus | Domain specialists produce detailed blueprints |
+| `/intuition-build` | sonnet | Delegates implementation, verifies against blueprints |
+| `/intuition-test` | opus | Post-build quality gate — test strategy and execution |
 
 ### Infrastructure
 
 | Skill | Model | Purpose |
 |-------|-------|---------|
 | `/intuition-start` | haiku | Detects phase, routes to next skill, version check |
-| `/intuition-handoff` | haiku | State transitions, brief generation, design loop |
+| `/intuition-handoff` | sonnet | Branch creation, v8 state transitions, migrations |
 | `/intuition-initialize` | haiku | Project memory setup (run once) |
 | `/intuition-update` | haiku | Package update manager |
 
+### Standalone Tools
+
+| Skill | Model | Purpose |
+|-------|-------|---------|
+| `/intuition-meander` | opus | Thought partner — reason through problems collaboratively |
+| `/intuition-think-tank` | opus | Rapid expert-panel analysis of documents, ideas, or proposals |
+
 ### Advisory
 
 | Skill | Model | Purpose |
@@ -73,21 +76,12 @@ Run `/clear` before each phase skill to keep context clean. Not every project ne
 
 ## Key Concepts
 
-### Engineer → Build Split
-
-- **Engineer** (opus) determines the code-level HOW: researches codebase, discusses decisions interactively, produces `code_specs.md`
-- **Build** (sonnet) implements against specs: delegates to subagents, verifies with reviewers, runs mandatory security review, produces `build_report.md`
-
 ### Trunk and Branches
 
 - **Trunk**: First prompt→build cycle — the foundation
 - **Branches**: Subsequent cycles that read parent context for continuity
 - After any cycle completes, `/intuition-start` offers branch creation or debugging
 
-### Design Loop
-
-The outline flags tasks needing design exploration. Handoff manages a loop: design one item → check for more → design next or advance to engineer.
-
 ### Project Memory
 
 All workflow state and knowledge lives in `docs/project_notes/`:
@@ -103,8 +97,7 @@ intuition/
 │   ├── intuition-start/           # Session primer + routing
 │   ├── intuition-prompt/          # Discovery refinement
 │   ├── intuition-outline/         # Strategic outlining
-│   ├── intuition-design/          # ECD design exploration
-│   ├── intuition-engineer/        # Code spec creation
+│   ├── intuition-meander/         # Thought partner
 │   ├── intuition-build/           # Implementation + verification
 │   ├── intuition-handoff/         # State transitions + briefs
 │   ├── intuition-debugger/        # Post-completion diagnostics

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tgoodington/intuition",
-  "version": "9.5.0",
+  "version": "10.1.0",
   "description": "Domain-adaptive workflow system for Claude Code: prompt, outline, assemble specialist teams, detail with domain experts, build with format producers, test code output. Supports v8 compat (design, engineer, build) and v9 specialist workflows with 14 domain specialists and 6 format producers.",
   "keywords": [
     "claude-code",

package/scripts/install-skills.js

@@ -46,8 +46,8 @@ const skills = [
   'intuition-prompt',
   'intuition-handoff',
   'intuition-outline',
-  'intuition-design',
-  'intuition-engineer',
+  'intuition-meander',
+  'intuition-think-tank',
   'intuition-build',
   'intuition-test',
   'intuition-debugger',
@@ -117,6 +117,19 @@ try {
     log(`Removed old /intuition-execute skill (split into /intuition-engineer + /intuition-build in v8.0)`);
   }
 
+  // Remove old design/engineer skills if they exist (removed in v10.0)
+  const oldDesignDest = path.join(claudeSkillsDir, 'intuition-design');
+  if (fs.existsSync(oldDesignDest)) {
+    fs.rmSync(oldDesignDest, { recursive: true, force: true });
+    log(`Removed old /intuition-design skill (removed in v10.0)`);
+  }
+
+  const oldEngineerDest = path.join(claudeSkillsDir, 'intuition-engineer');
+  if (fs.existsSync(oldEngineerDest)) {
+    fs.rmSync(oldEngineerDest, { recursive: true, force: true });
+    log(`Removed old /intuition-engineer skill (removed in v10.0)`);
+  }
+
   // Remove old plan skill if it exists (renamed to outline in v9.1)
   const oldPlanDest = path.join(claudeSkillsDir, 'intuition-plan');
   if (fs.existsSync(oldPlanDest)) {
@@ -229,8 +242,8 @@ try {
     log(`  /intuition-prompt         - Focused discovery (prompt-engineering refinement)`);
     log(`  /intuition-handoff        - Handoff orchestrator (phase transitions + design loop)`);
     log(`  /intuition-outline        - Strategic outline (ARCH protocol + design flagging)`);
-    log(`  /intuition-design         - Design exploration (ECD framework, domain-agnostic)`);
-    log(`  /intuition-engineer       - Code spec creator (engineering decisions)`);
+    log(`  /intuition-meander        - Thought partner (reasoning + exploration)`);
+    log(`  /intuition-think-tank     - Rapid expert-panel analysis`);
     log(`  /intuition-assemble       - Team assembler (v9 specialist/producer matching)`);
     log(`  /intuition-detail         - Domain specialist orchestrator (v9 detail phase)`);
     log(`  /intuition-build          - Build manager (blueprint + producer delegation)`);

package/scripts/uninstall-skills.js

@@ -46,6 +46,9 @@ try {
     'intuition-prompt',
     'intuition-handoff',
     'intuition-outline',
+    'intuition-meander',
+    'intuition-think-tank',
+    // Legacy skills (removed in v10.0)
     'intuition-design',
     'intuition-engineer',
     'intuition-build',

package/skills/intuition-build/SKILL.md

@@ -79,6 +79,7 @@ Read these files:
 5. `{context_path}/scratch/*-decisions.json` (all specialist decision logs) — decision tiers and chosen options.
 6. `{context_path}/prompt_brief.md` — Commander's Intent, success criteria, non-negotiables (for Vision Alignment in report).
 7. `{context_path}/vision-review.md` (if exists) — flagged items from detail's vision review that build should address.
+8. `{context_path}/process_flow.md` (if exists) — end-to-end user flows, component interactions, data paths, error paths. Used for flow verification in Layer 2 and as orientation context for producers.
 
 From team_assignment.json, extract:
 - `specialist_assignments` — which specialist owns which tasks
@@ -165,6 +166,9 @@ The full blueprint contains all specifications — do not deviate from them.
 
 Output directory: [from blueprint's Producer Handoff]
 Output files: [from blueprint's Producer Handoff]
+
+## Flow Context (if process_flow.md exists)
+[Extract the relevant flow segment from process_flow.md showing where this deliverable fits in the end-to-end path. This is for orientation only — your specifications come from the blueprint.]
 ```
 
 When building on a branch, add to subagent prompts:
@@ -218,6 +222,16 @@ Check the deliverable yourself against outline.md acceptance criteria:
 
 Log all deviations (additions and omissions) in the build report's "Deviations from Blueprint" section, even if they seem minor.
 
+**Process flow verification (conditional):**
+If `{context_path}/process_flow.md` exists, verify the produced deliverables match the described end-to-end flows:
+- Trace each Core Flow's path against the implemented code. Do the components interact as described?
+- Check that error paths described in process_flow.md have corresponding implementation.
+- Check that integration seams have matching contracts on both sides.
+
+Log any mismatches in the build report under "Process Flow Deviations." If a deviation affects what the end user sees or experiences, escalate via AskUserQuestion with options: "Fix the code to match the process flow" / "Accept the deviation" / "I need to think about this." If the user accepts a deviation, note in the build report that process_flow.md is stale at that section.
+
+In **fast track mode**, treat process_flow.md as advisory only — log observations but do not escalate deviations (the document is in skeletal draft form without detail refinement).
+
 - If FAIL → send feedback back to the producer with specific acceptance criteria gaps. Do NOT proceed to Layer 3.
 - If PASS → proceed to Layer 3.
 
@@ -322,6 +336,13 @@ Write the build report to `{context_path}/build_report.md` AND display a summary
 
 [If no test deliverables were found in any blueprint, write "No test deliverables found in blueprints."]
 
+## Process Flow Deviations
+[Cross-cutting deviations between implementation and process_flow.md. If no process_flow.md exists, write "N/A — no process flow document." If no deviations, write "None — implementation matches process flows."]
+
+| Flow | Deviation | Resolution |
+|------|-----------|------------|
+| [flow name] | [what differs] | [Fixed / Accepted — user approved / Flagged for update] |
+
 ## Vision Alignment
 [Read `{context_path}/prompt_brief.md` — extract Success Criteria and Commander's Intent non-negotiables. Map each to the produced output.]
 

package/skills/intuition-debugger/SKILL.md

@@ -3,7 +3,7 @@ name: intuition-debugger
 description: Expert diagnostic and resolution service for completed workflow contexts. Investigates issues holistically — considering architectural alignment, security, ripple effects, maintenance burden, and functional correctness — then presents solution options in plain language for a non-technical creative director. Generates fast-track briefs when issues require upstream workflow passes.
 model: opus
 tools: Read, Write, Edit, Glob, Grep, Agent, AskUserQuestion, Bash, mcp__ide__getDiagnostics
-allowed-tools: Read, Write, Edit, Glob, Grep, Bash, mcp__ide__getDiagnostics
+allowed-tools: Read, Write, Edit, Glob, Grep, Agent, Bash, mcp__ide__getDiagnostics
 ---
 
 # CRITICAL RULES
@@ -105,10 +105,11 @@ Read ALL of these before proceeding — build your understanding of what was bui
 - `docs/project_notes/bugs.md` — previously logged bugs
 - `{context_path}/scratch/*-decisions.json` — specialist decisions (if any exist)
 
-Also check for blueprints:
+Also check for blueprints and process flow:
 - `{context_path}/blueprints/*.md` — detailed specialist blueprints (if detail phase ran)
+- `{context_path}/process_flow.md` (if exists) — end-to-end user flows, component interactions, data paths, error paths, state mutations, integration seams, known invariants. This is your primary map of how the app works. Use it to understand upstream/downstream impact before reading source code.
 
-The gap between intended approach and actual implementation is where bugs hide. The decisions files tell you what constraints MUST be preserved.
+The gap between intended approach and actual implementation is where bugs hide. The decisions files tell you what constraints MUST be preserved. The process flow document tells you how the pieces connect — trace the reported issue through the flow to understand the full impact chain.
 
 Do NOT read source code files yet. Read targeted code only after the user describes the issue.
 
@@ -164,7 +165,8 @@ With the root cause identified, evaluate through EVERY lens:
 - Check: input validation, output encoding, auth boundaries, data exposure.
 
 **Ripple Effects:**
-- Launch an `intuition-researcher` agent to map the dependency graph:
+- If `{context_path}/process_flow.md` exists, start with it: identify which Core Flows pass through the affected area, what's upstream and downstream, and what state mutations or integration seams are involved. Use the Component Dependencies and Integration Seams sections to pre-map the blast radius before launching a researcher.
+- Launch an `intuition-researcher` agent to verify and extend the process flow mapping against actual code:
   ```
   "Map all imports, usages, and dependents of [affected module/function/interface]
   across the codebase. Report: file paths, line numbers, how each usage depends
@@ -395,6 +397,14 @@ After the subagent returns:
 - **Prevention**: [How to avoid in future — what should the build process catch?]
 ```
 
+**Update process flow (conditional)** — If `{context_path}/process_flow.md` exists AND the fix changes how a flow actually works (e.g., adds error handling that changes an error path, restructures a component interaction, or modifies state mutations):
+1. Read the current process_flow.md
+2. Update ONLY the specific flow section affected by the fix
+3. Add an entry to the Flow History table: `| [YYYY-MM-DD] | Debugger | [What changed] | [Fix for: brief issue description] |`
+4. Add or update the Known Fragile Areas section if the investigation revealed a fragile pattern
+
+Do NOT update process_flow.md for fixes that don't change flow behavior (e.g., fixing a typo, correcting a calculation that doesn't change the data path). Do NOT rewrite the Overview or restructure the document. When generating a fast-track brief (upstream fix), do NOT update process_flow.md — the upstream workflow will update it after implementing changes.
+
 **Save Intuition memory** — When the investigation reveals something with cross-conversation value, save a memory file to `C:\Users\tgoodington\.claude\projects\C--Claude-Projects-Intuition\memory\`:
 
 Save a memory when:

package/skills/intuition-detail/SKILL.md

@@ -404,6 +404,29 @@ Triggers when Step 8d finds no remaining specialists.
 
 **9a. Conflict detection.** Spawn an `intuition-researcher` agent: "Read all blueprint files in `{context_path}/blueprints/`. Compare for: contradictory decisions, overlapping file modifications with conflicting changes, inconsistent interface assumptions, and duplicated work. Write findings to `{context_path}/blueprint-conflicts.md`. If no conflicts, write 'No conflicts detected.'" Wait for completion. If conflicts found, present to user via AskUserQuestion and resolve before continuing.
 
+**9a-ii. Process flow synthesis (conditional).** Skip this step if `{context_path}/process_flow.md` does not exist (non-code project or Lightweight outline).
+
+If `process_flow.md` exists, spawn an `intuition-synthesizer` agent:
+
+"Read these files:
+1. `{context_path}/process_flow.md` — the outline's initial WHAT-level flow draft
+2. For each blueprint in `{context_path}/blueprints/`: read Section 3 (Approach) and Section 7 (Integration Points) only
+
+Refine the process flow document with specialist knowledge. The outline draft describes flows at the WHAT level. Your job is to add the HOW:
+- Fill in concrete data paths, state transitions, and error propagation chains from the blueprints
+- Add state mutations per flow (which stores are written, by which step)
+- Add known invariants per flow (things that MUST remain true)
+- Populate the Component Dependencies section from blueprint integration points
+- Populate Integration Seams with contracts and failure modes
+- Resolve any conflicts between the outline's assumed flows and specialist approaches (specialist knowledge supersedes outline assumptions — they had deeper research)
+- Update the Flow History table
+
+Keep the document under 200 lines for Standard-tier projects, under 400 for Comprehensive. Be terse — structured steps, not prose.
+
+Write the refined document to `{context_path}/process_flow.md` (overwriting the outline's draft)."
+
+Wait for completion. If the vision review (9b) later triggers a specialist re-run, re-run this synthesis step after the re-run completes.
+
 **9b. Vision review.** Skip this step if only 1 specialist completed (no cross-specialist seams to check).
 
 For multi-specialist projects, spawn an `intuition-reviewer` agent:
@@ -411,7 +434,8 @@ For multi-specialist projects, spawn an `intuition-reviewer` agent:
 "Read these files:
 1. `{context_path}/prompt_brief.md` — extract Commander's Intent (desired end state, non-negotiables, boundaries) and Success Criteria
 2. `{context_path}/outline.md` — extract the task list and acceptance criteria
-3. For each blueprint in `{context_path}/blueprints/`: read the Approach section (Section 3) and Acceptance Mapping section (Section 6) only — skip the full deliverable specs
+3. `{context_path}/process_flow.md` (if exists) — the refined end-to-end flow document. Check that flows honor Commander's Intent and that no seams are missing.
+4. For each blueprint in `{context_path}/blueprints/`: read the Approach section (Section 3) and Acceptance Mapping section (Section 6) only — skip the full deliverable specs
 
 Then evaluate the blueprints AS A WHOLE against the original vision:
 

package/skills/intuition-initialize/SKILL.md

@@ -3,7 +3,7 @@ name: intuition-initialize
 description: Set up project memory infrastructure with workflow state tracking, memory files, and configuration templates.
 model: haiku
 tools: Read, Write, Glob, Grep, Bash, AskUserQuestion
-allowed-tools: Read, Write, Glob, Grep
+allowed-tools: Read, Write, Glob, Grep, Bash
 ---
 
 # Initialize - Project Memory Setup Protocol

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

@@ -2,7 +2,7 @@
 
 ## 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.
+This project uses a multi-agent system coordinated by Intuition (`@tgoodington/intuition`), a Claude Code skill system. Specialized skills handle prompt refinement, planning, domain-specialist detailing, and build execution, with memory maintained in `docs/project_notes/` for consistency across sessions.
 
 ## Workflow Skills
 
@@ -12,9 +12,10 @@ This project uses a multi-agent system coordinated by Intuition (`@tgoodington/i
 |-------|-------|-------------|
 | `/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 |
+| `/intuition-assemble` | sonnet | Matches tasks to domain specialists and format producers |
+| `/intuition-detail` | opus | Domain specialists produce detailed blueprints through exploration and user gates |
+| `/intuition-build` | sonnet | Delegates implementation to subagents, verifies outputs against blueprints and acceptance criteria |
+| `/intuition-test` | opus | Post-build quality gate — test strategy design and execution |
 
 ### Infrastructure
 
@@ -29,6 +30,8 @@ This project uses a multi-agent system coordinated by Intuition (`@tgoodington/i
 
 | Skill | Model | What it does |
 |-------|-------|-------------|
+| `/intuition-meander` | opus | Thought partner — collaborative reasoning and problem exploration |
+| `/intuition-think-tank` | opus | Rapid expert-panel analysis of documents, ideas, or proposals |
 | `/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 |
@@ -41,12 +44,11 @@ This project uses a multi-agent system coordinated by Intuition (`@tgoodington/i
 
 ## Workflow
 
-### Trunk (first cycle)
+### Trunk (first cycle, v9)
 
 ```
-/intuition-prompt → handoff → /intuition-outline → handoff →
-  [/intuition-design loop] → handoff → /intuition-engineer → handoff →
-  /intuition-build → handoff → complete
+/intuition-prompt → /intuition-outline → /intuition-assemble →
+  /intuition-detail → /intuition-build → /intuition-test → complete
 ```
 
 Each handoff transition:
@@ -64,18 +66,9 @@ After trunk completes, run `/intuition-start` to:
 
 Branches follow the same 5-phase workflow but read parent context for continuity.
 
-### Design Loop (optional)
+### Detail Phase (v9)
 
-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
+The outline assesses every task by domain and depth. The assemble phase matches tasks to domain specialists. The detail phase runs each specialist through exploration → user gate → blueprint specification.
 
 ## Build Sub-Agents
 

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

@@ -5,13 +5,11 @@ This project uses a five-phase workflow coordinated by the Intuition system, wit
 ### Workflow Model
 
 The Intuition workflow uses a trunk-and-branch model:
-- **Trunk**: The first prompt→plan→design→engineer→build cycle. Represents the core vision.
+- **Trunk**: The first prompt→outline→detail→build→test 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
+v9 workflow: `/intuition-prompt` → `/intuition-outline` → `/intuition-assemble` → `/intuition-detail` → `/intuition-build` → `/intuition-test` → complete
 
 After completion: `/intuition-start` to create branches or `/intuition-debugger` to debug issues.
 
@@ -36,29 +34,30 @@ The project follows a structured workflow with handoff transitions between phase
 - 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
+**Assemble** — `/intuition-assemble`
+- Matches outline tasks to domain specialists and format producers
+- Writes team_assignment.json for the detail phase
 
-**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
+**Detail** — `/intuition-detail`
+- Domain specialists produce detailed blueprints
+- Stage 1 exploration → user gate → Stage 2 specification
+- Output: Blueprints per specialist domain
 
 **Build** — `/intuition-build`
-- Delegates implementation to subagents, verifies against code specs and acceptance criteria
+- Delegates implementation to format producers, verifies against blueprints 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
+- Output: `build_report.md` — task outcomes, files modified
+
+**Test** — `/intuition-test`
+- Post-build quality gate
+- Designs test strategy, creates tests, runs fix cycles
+- Output: `test_report.md`
 
 **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
+**Recommended Flow (v9)**: Prompt → Outline → Assemble → Detail → Build → Test → complete
 
 Run `/clear` before each phase skill. After completion, run `/intuition-start` to create a branch or invoke `/intuition-debugger` to debug issues.
 
@@ -74,11 +73,11 @@ Run `/clear` before each phase skill. After completion, run `/intuition-start` t
 **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)
+- **team_assignment.json** — Specialist/producer assignments (created by Assemble)
+- **blueprints/** — Detailed blueprints per specialist (created by Detail)
+- **build_brief.md** — Brief for build phase (created by Handoff, v8)
 - **build_report.md** — Task outcomes and files modified (created by Build)
+- **test_report.md** — Test results and coverage (created by Test)
 
 ### Memory-Aware Protocols
 
@@ -115,20 +114,17 @@ Run `/clear` before each phase skill. After completion, run `/intuition-start` t
 **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 outline is ready:**
+- "Outline looks ready! Use `/intuition-assemble` to match tasks to specialists."
 
-**When user is ready to engineer:**
-- "Engineering brief is ready! Use `/intuition-engineer` to create code specifications."
+**When assembly is complete:**
+- "Team assigned! Use `/intuition-detail` to start the specialist blueprint phase."
 
-**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 detail is complete:**
+- "Blueprints ready! Use `/intuition-build` to kick off implementation."
 
 **When build is complete:**
+- "Build done! Use `/intuition-test` to run the quality gate."
+
+**When test 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

@@ -1,26 +1,19 @@
 # Intuition
 
-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.
+A trunk-and-branch workflow system for Claude Code. Turns rough ideas into structured plans, specialist-driven blueprints, and verified implementations through guided dialogue.
 
 ## Workflow
 
 ```
-/intuition-prompt  →  /intuition-handoff  →  /intuition-outline  →  /intuition-handoff
-                                                                        ↓
-                                                              [design loop, if needed]
-                                                                        ↓
-                                                               /intuition-handoff  →  /intuition-engineer
-                                                                                            ↓
-                                               /intuition-build  ←  /intuition-handoff
-                                                        ↓
-                                               /intuition-handoff  →  complete
-                                                        ↓
-                              /intuition-start  →  create branch  or  /intuition-debugger
+/intuition-prompt → /intuition-outline → /intuition-assemble →
+  /intuition-detail → /intuition-build → /intuition-test → complete
+        ↓
+  /intuition-start → create branch or /intuition-debugger
 ```
 
-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.
+Run `/clear` before each new phase skill to keep context clean.
 
-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.
+The first 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,13 +21,16 @@ 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-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 |
+| `/intuition-outline` | Builds a strategic blueprint with tasks, depth assessment, and domain classification |
+| `/intuition-assemble` | Matches tasks to domain specialists and format producers |
+| `/intuition-detail` | Domain specialists produce detailed blueprints through exploration and user gates |
+| `/intuition-build` | Delegates implementation to subagents, verifies against blueprints and acceptance criteria |
+| `/intuition-test` | Post-build quality gate — test strategy design and execution |
 | `/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-handoff` | Branch creation, v8 state transitions, migrations |
 | `/intuition-initialize` | Sets up project memory (you already ran this) |
+| `/intuition-meander` | Thought partner — reason through problems collaboratively |
+| `/intuition-think-tank` | Rapid expert-panel analysis of documents, ideas, or proposals |
 
 ## Quick Start
 
@@ -42,17 +38,13 @@ 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 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
-8. `/intuition-engineer` — create code specifications
-9. `/intuition-handoff` — prepare for build
-10. `/intuition-build` — implement and verify
-11. `/intuition-handoff` — complete the cycle
+3. `/intuition-outline` — create the blueprint
+4. `/intuition-assemble` — match tasks to specialists
+5. `/intuition-detail` — specialists produce blueprints
+6. `/intuition-build` — implement and verify
+7. `/intuition-test` — quality gate
 
-Not every project needs design. If the plan is clear enough, handoff skips straight to engineer. Run `/clear` before each phase skill.
+Run `/clear` before each phase skill.
 
 ### After trunk completes (branches)