@tgoodington/intuition 8.1.3 → 9.2.1

package/skills/intuition-handoff/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: intuition-handoff
-description: Universal phase transition orchestrator. Processes phase outputs, updates project memory, generates fresh briefs for next agent. Manages the design loop for multi-item design cycles.
-model: haiku
+description: Universal phase transition orchestrator. Processes phase outputs, updates project memory, generates fresh briefs for next agent. Manages the design loop for multi-item design cycles and v9 team assembly for specialist workflows.
+model: sonnet
 tools: Read, Write, Glob, Grep, AskUserQuestion, Bash
 allowed-tools: Read, Write, Glob, Grep, Bash
 ---
@@ -21,9 +21,9 @@ These are non-negotiable. Violating any of these means the protocol has failed.
 5. You MUST generate a brief for the next agent.
 6. You MUST update `.project-memory-state.json` — you are the ONLY skill that writes to this file.
 7. You MUST NOT evaluate or critique phase outputs. Process and document, never judge.
-8. You MUST NOT skip the user profile merge step during prompt→planning transitions.
+8. You MUST NOT skip the user profile merge step during prompt→outline transitions.
 9. You MUST suggest the correct next skill after completing the transition.
-10. You MUST NOT modify discovery_brief.md, plan.md, design_spec_*.md, code_specs.md, or other phase output files — they are read-only inputs.
+10. You MUST NOT modify prompt_brief.md, outline.md, design_spec_*.md, code_specs.md, or other phase output files — they are read-only inputs.
 11. You MUST manage the design loop: track which items are designed, route to next item or to engineer when all are done.
 
 ## CONTEXT PATH RESOLUTION
@@ -41,15 +41,25 @@ Before ANY transition, resolve the active context:
 6. Use `context_workflow` for all status checks and state writes
 7. Shared files (key_facts.md, decisions.md, issues.md, bugs.md) always stay at `docs/project_notes/` — do NOT use context_path for these.
 
+## MODE DETECTION
+
+After resolving context_path, determine the workflow version:
+
+1. Read `{context_path}outline.md` (if it exists)
+2. IF outline contains a `### 6.5 Detail Assessment` section → **v9 mode**
+3. IF outline contains a `Design Recommendations` section OR no outline exists yet → **v8 mode**
+4. Store the detected mode for use in transition detection below.
+
 ## PROTOCOL: COMPLETE FLOW
 
 ```
 Step 1: Resolve context_path and context_workflow (see above)
+Step 1.5: Detect mode (v8 or v9)
 Step 2: Detect transition type from context_workflow
 Step 3: Read phase output files from {context_path}
 Step 4: Extract insights and structure findings
 Step 5: Update shared memory files (key_facts.md, decisions.md, issues.md)
-Step 6: Merge user profile learnings (prompt→planning only)
+Step 6: Merge user profile learnings (prompt→outline only)
 Step 7: Generate brief for next agent at {context_path}
 Step 8: Update .project-memory-state.json (target active context object)
 Step 9: Report what was processed and suggest next skill
@@ -57,18 +67,30 @@ Step 9: Report what was processed and suggest next skill
 
 ## STEP 1: DETECT TRANSITION
 
-After resolving context_path and context_workflow, determine:
+After resolving context_path, context_workflow, and mode:
 
 ```
 IF context_workflow.status == "prompt" AND workflow.prompt.completed == true
-   AND workflow.planning.started == false:
-   → TRANSITION: Prompt → Planning (Transition 1)
-
-IF context_workflow.status == "planning" AND workflow.planning.completed == true
-   AND workflow.design.started == false AND workflow.engineering.started == false:
-   → TRANSITION: Planning → Design (Transition 2) OR Planning → Engineer (Transition 2B)
-
-IF context_workflow.status == "design":
+   AND workflow.outline.started == false:
+   → TRANSITION: Prompt → Outline (Transition 1)
+
+IF context_workflow.status == "outline" AND workflow.outline.completed == true:
+   IF v9 mode AND NOT (workflow.detail exists AND workflow.detail.started == true):
+      IF {context_path}team_assignment.json exists:
+         → TRANSITION: Assemble → Detail (Transition 2.5v9)
+      ELSE:
+         → TRANSITION: Outline → Assemble (Transition 2v9)
+   ELSE IF v8 mode AND workflow.design.started == false AND workflow.engineering.started == false:
+      → TRANSITION: Outline → Design (Transition 2) OR Outline → Engineer (Transition 2B)
+
+IF v9 mode AND context_workflow.status == "detail":
+   → Check workflow.detail.specialists array
+   → IF current specialist status == "completed" AND more specialists remain in current or later execution phases:
+      → TRANSITION: Specialist → Specialist (Transition 3v9)
+   → IF ALL specialists completed:
+      → TRANSITION: Detail → Build (Transition 4v9)
+
+IF v8 mode AND context_workflow.status == "design":
    → Check workflow.design.items array
    → IF current item just completed AND more items remain:
       → TRANSITION: Design → Design (Transition 3)
@@ -77,32 +99,44 @@ IF context_workflow.status == "design":
 
 IF context_workflow.status == "engineering" AND workflow.engineering.completed == true
    AND workflow.build.started == false:
-   → TRANSITION: Engineer → Build (Transition 5)
+   → TRANSITION: Engineer → Build (Transition 5) — v8 only
 
 IF context_workflow.status == "building" AND workflow.build.completed == true:
-   → TRANSITION: Build → Complete (Transition 6)
+   IF v9 mode AND workflow.test.started == false:
+      Read {context_path}/team_assignment.json
+      IF any producer_assignments entry has producer == "code-writer":
+         → TRANSITION: Build → Test (Transition 6.5v9)
+      ELSE:
+         → TRANSITION: Build → Complete (Transition 6)
+   ELSE IF v8 mode:
+      → TRANSITION: Build → Complete (Transition 6)
+
+IF context_workflow.status == "testing" AND workflow.test.completed == true:
+   → TRANSITION: Test → Complete (Transition 7)
 
 IF no clear transition detected:
    → ASK USER: "Which phase just completed?" (use AskUserQuestion)
 ```
 
-## STATE SCHEMA (v5.0)
+## STATE SCHEMA (v8.0)
 
 This is the authoritative schema for `.project-memory-state.json`:
 
 ```json
 {
   "initialized": true,
-  "version": "5.0",
+  "version": "8.0",
   "active_context": "trunk",
   "trunk": {
-    "status": "none | prompt | planning | design | engineering | building | complete",
+    "status": "none | prompt | outline | design | engineering | building | testing | detail | complete",
     "workflow": {
       "prompt": { "started": false, "completed": false, "started_at": null, "completed_at": null, "output_files": [] },
-      "planning": { "started": false, "completed": false, "completed_at": null, "approved": false },
+      "outline": { "started": false, "completed": false, "completed_at": null, "approved": false },
       "design": { "started": false, "completed": false, "completed_at": null, "items": [], "current_item": null },
       "engineering": { "started": false, "completed": false, "completed_at": null },
-      "build": { "started": false, "completed": false, "completed_at": null }
+      "build": { "started": false, "completed": false, "completed_at": null },
+      "test": { "started": false, "completed": false, "completed_at": null, "skipped": false },
+      "detail": { "started": false, "completed": false, "completed_at": null, "team_assignment": null, "specialists": [], "current_specialist": null, "execution_phase": 1 }
     }
   },
   "branches": {},
@@ -113,12 +147,16 @@ This is the authoritative schema for `.project-memory-state.json`:
 
 ### Branch Entry Schema
 
-Each branch in `branches` has: `display_name`, `created_from`, `created_at`, `purpose`, `status`, and a `workflow` object identical to trunk's workflow structure (including `engineering` and `build` phases).
+Each branch in `branches` has: `display_name`, `created_from`, `created_at`, `purpose`, `status`, and a `workflow` object identical to trunk's workflow structure (including `engineering`, `build`, `test`, and `detail` phases).
 
 ### Design Items Schema
 
 Each item in `design.items`: `{ "name": "snake_case", "display_name": "Human Name", "status": "pending|in_progress|completed|skipped", "plan_tasks": [N], "spec_file": null, "flagged_reason": "..." }`
 
+### Detail Specialist Schema (v9)
+
+Each entry in `detail.specialists`: `{ "name": "specialist-name", "tasks": [{"task_id": "T1", "depth": "Deep"}], "status": "pending|in_progress|completed", "stage": "stage1|user_gate|stage2|done", "stage1_path": null, "decisions_path": null, "blueprint_path": null }`
+
 When updating state, preserve all existing fields and only modify the relevant ones. Always set `last_handoff` to the current ISO timestamp and `last_handoff_transition` to the transition name.
 
 ### State Write Pattern
@@ -146,309 +184,306 @@ Triggered when start routes to handoff with branch creation intent. User has pro
    - `created_at`: ISO timestamp
    - `purpose`: user-provided sentence
    - `status`: "none"
-   - `workflow`: identical structure to trunk's workflow (all false/null/empty — including `engineering` and `build` phases)
+   - `workflow`: identical structure to trunk's workflow (all false/null/empty — including `engineering`, `build`, `test`, and `detail` phases)
 4. **Set `active_context`** to the new branch key.
 5. **Write updated state**. Set `last_handoff_transition` to "branch_creation".
 6. **Route user**: "Branch **[display_name]** created. Run `/clear` then `/intuition-prompt` to define what this branch will accomplish."
 
-## V4 STATE MIGRATION
+## V7 STATE MIGRATION
 
-Fires automatically when handoff detects a v4.0 state before processing any transition.
+Fires when handoff detects `version == "7.0"`. For trunk and every branch: rename the `planning` key to `outline` in the `workflow` object (preserving all sub-fields: started, completed, completed_at, approved), and change any `status == "planning"` to `"outline"`. Set `version: "8.0"`, preserve all other fields, write state. Report: "Migrated state from v7.0 to v8.0 (renamed planning → outline)." Then continue with the original transition.
 
-### Detection
+## V5 STATE MIGRATION
 
-`version == "4.0"` OR (state has `execution` phase in workflow but no `engineering` phase).
+Fires when handoff detects `version == "5.0"`. For trunk and every branch: if `workflow.detail` does not exist, add `"detail": { "started": false, "completed": false, "completed_at": null, "team_assignment": null, "specialists": [], "current_specialist": null, "execution_phase": 1 }` after `build` in the workflow object. Also add `"test": { "started": false, "completed": false, "completed_at": null, "skipped": false }` after `build`. Set `version: "7.0"`, preserve all other fields, write state. Report: "Migrated state from v5.0 to v7.0 (added detail phase + test phase)." Then continue with the original transition.
 
-### Migration Steps
+## V6 STATE MIGRATION
 
-1. For trunk and every branch, transform the workflow object:
-   - Rename `execution` → `build` (preserve all field values)
-   - Add `engineering: { "started": false, "completed": false, "completed_at": null }` before `build`
-   - If a context has `status == "executing"`, change to `status = "building"`
-2. Set `version: "5.0"`
-3. Preserve all other fields unchanged.
-4. Write updated state.
-5. Report to user: "Migrated state from v4.0 to v5.0 (added engineering phase, renamed execution → build)." Then continue with the original transition.
+Fires when handoff detects `version == "6.0"`. For trunk and every branch: if `workflow.test` does not exist, add `"test": { "started": false, "completed": false, "completed_at": null, "skipped": false }` after `build` in the workflow object. Set `version: "7.0"`, preserve all other fields, write state. Report: "Migrated state from v6.0 to v7.0 (added test phase for post-build quality gate)." Then continue with the original transition.
+
+## V4 STATE MIGRATION
+
+Fires when handoff detects `version == "4.0"` OR (`execution` phase exists but no `engineering` phase). For trunk and every branch: rename `execution` → `build`, add `engineering: { "started": false, "completed": false, "completed_at": null }` before `build`, change any `status == "executing"` to `"building"`. Set `version: "5.0"`, preserve all other fields, write state. Report: "Migrated state from v4.0 to v5.0 (added engineering phase, renamed execution → build)." Then continue with the original transition.
 
 ## V3 STATE MIGRATION
 
-Fires automatically when handoff detects a v3.0 state before processing any transition.
+Fires when handoff detects `version == "3.0"` OR missing `active_context`. Create `docs/project_notes/trunk/`. Move existing workflow artifacts (`prompt_brief.md`, `prompt_output.json`, `planning_brief.md`, `plan.md`, `design_brief.md`, `design_spec_*.md`, `execution_brief.md`, `.planning_research/`) from `docs/project_notes/` into `trunk/` — skip missing files. Restructure state: wrap existing `status` + `workflow` into `trunk` object, add `active_context: "trunk"`, `branches: {}`, rename `execution` → `build`, add `engineering` phase, set `version: "5.0"`. Preserve `initialized`, `last_handoff`, `last_handoff_transition`. Write state. Report what was migrated and confirm v5.0 upgrade. Leave shared files (`key_facts.md`, `decisions.md`, `issues.md`, `bugs.md`) at `docs/project_notes/`.
 
-### Detection
+## TRANSITION 1: PROMPT → OUTLINE
 
-`version == "3.0"` OR missing `active_context` field in state.
+Read `{context_path}prompt_brief.md` and `{context_path}prompt_output.json` (if exists — fall back to extracting from brief manually).
 
-### Migration Steps
+**Extract and Structure:** Key facts → `key_facts.md`, constraints → `key_facts.md` (constraints category), suggested decisions → ADRs in `decisions.md`, assumptions → reference in brief only, follow-up items → `issues.md`.
 
-1. Create `docs/project_notes/trunk/` directory.
-2. Move existing workflow artifacts from `docs/project_notes/` into `docs/project_notes/trunk/`:
-   - `discovery_brief.md`, `discovery_output.json`, `planning_brief.md`, `plan.md`
-   - `design_brief.md`, `design_spec_*.md`, `execution_brief.md`
-   - `.planning_research/` directory (entire folder)
-   - Only move files that exist. Skip missing files silently.
-3. Restructure state:
-   - Wrap existing `status` and `workflow` into a `trunk` object
-   - Add `active_context: "trunk"`
-   - Add `branches: {}`
-   - Transform workflow: rename `execution` → `build`, add `engineering` phase
-   - Set `version: "5.0"`
-   - Preserve all other top-level fields (`initialized`, `last_handoff`, `last_handoff_transition`)
-4. Write updated state.
-5. Report to user: list which files were migrated and confirm v5.0 upgrade. Then continue with the original transition.
+**User Profile Merge:** If `prompt_output.json` has `user_profile_learnings` AND `.claude/USER_PROFILE.json` exists: read profile, merge (null fields get new values, populated fields overwrite only if confidence "high"), save. Skip if no USER_PROFILE.json.
 
-Leave shared files (`key_facts.md`, `decisions.md`, `issues.md`, `bugs.md`) at `docs/project_notes/` — do NOT move them.
+**Generate Outline Brief:** Write `{context_path}outline_brief.md` with: Discovery Summary (1-2 paragraphs), Problem Statement, Goals & Success Criteria, Key Constraints, Architectural Context, Assumptions & Risks (with confidence levels), References (prompt_brief path, ADR numbers).
 
-## TRANSITION 1: PROMPT → PLANNING
+Update state: set `status` to `"outline"`, mark `prompt.completed = true` with timestamp, set `outline.started = true`. Route: "Prompt output processed. Outline brief saved to `{context_path}outline_brief.md`. Run `/clear` then `/intuition-outline` to create a structured plan."
 
-### Read Outputs
+## TRANSITION 2: OUTLINE → DESIGN (Initial Setup)
 
-Read from `{context_path}`:
-- `{context_path}discovery_brief.md` — human-readable discovery summary
-- `{context_path}discovery_output.json` — structured data (if exists)
+v8 mode only. Read `{context_path}outline.md`. Find "Design Recommendations" section — extract items flagged for design with rationale and task numbers (if no section, assess tasks yourself). Extract: decisions → `decisions.md`, risks/dependencies → include in brief, outline work → `issues.md`.
 
-If `discovery_output.json` doesn't exist, extract insights manually from `discovery_brief.md`.
+**Present to user** via AskUserQuestion (header: "Design Items"): list each flagged item with rationale. Options: "All recommended items need design" / "Some items — let me specify" / "None — skip design, go straight to engineering". If "Some," follow up. If "None," use Transition 2B.
 
-### Extract and Structure
+**Generate Design Brief:** Write `{context_path}design_brief.md` for FIRST item with: Current Item, Plan Context (1-2 paragraphs), Task Details (numbers, description, acceptance criteria, dependencies), Design Rationale, Constraints, Design Queue (all items with status), References.
 
-From the outputs, identify:
-- **Key facts** → add to `docs/project_notes/key_facts.md`
-- **Constraints** → add to `docs/project_notes/key_facts.md` under constraints category
-- **Suggested decisions** → create ADRs in `docs/project_notes/decisions.md`
-- **Assumptions** → reference in brief, not directly added to memory
-- **Follow-up items** → add to `docs/project_notes/issues.md`
+Update state: set `status` to `"design"`, mark `outline.completed = true` with timestamp and `approved = true`, set `design.started = true`, populate `design.items`, set `design.current_item` to first item (`"in_progress"`). Route: "Outline processed. Design brief prepared for **[First Item Name]**. Run `/clear` then `/intuition-design` to begin design exploration."
 
-### User Profile Merge
+## TRANSITION 2B: OUTLINE → ENGINEER (Skip Design)
 
-If `{context_path}discovery_output.json` contains `user_profile_learnings` AND `.claude/USER_PROFILE.json` exists:
-1. Read existing USER_PROFILE.json
-2. Merge learnings (null fields get new values; populated fields only overwrite if confidence is "high")
-3. Save updated profile
+v8 mode only. Used when user confirms NO items need design. Write `{context_path}engineering_brief.md` with: Plan Summary (1-2 paragraphs), Objective, Discovery Context, Task Summary, Known Risks, References.
 
-If USER_PROFILE.json does NOT exist, skip this step.
+Update state: set `status` to `"engineering"`, mark `outline.completed = true` with timestamp and `approved = true`, set `design.started = false`, `design.completed = false`, `design.items = []`, set `engineering.started = true`. Route: "Outline processed. No design items flagged. Engineering brief saved to `{context_path}engineering_brief.md`. Run `/clear` then `/intuition-engineer` to create code specs."
 
-### Generate Planning Brief
+## TRANSITION 2v9: OUTLINE → ASSEMBLE
 
-Write `{context_path}planning_brief.md` with these sections:
-- **Discovery Summary** (1-2 paragraphs)
-- **Problem Statement**
-- **Goals & Success Criteria**
-- **Key Constraints**
-- **Architectural Context** (existing decisions/patterns)
-- **Assumptions & Risks** (with confidence levels)
-- **References** (discovery_brief path, relevant ADR numbers)
+v9 mode only. Triggers when outline completes and the plan contains a `### 6.5 Detail Assessment` section.
 
-### Update State
+### Protocol
 
-Update the active context: set `status` to `"planning"`, mark `prompt.completed = true` with timestamp, set `planning.started = true`.
+1. **Extract and structure** from outline.md: architectural decisions → `docs/project_notes/decisions.md`, risks/dependencies → note for brief, outline insights → `docs/project_notes/issues.md`.
+2. **Update state**: Set `status` to `"outline"`, mark `outline.completed = true` with timestamp, `approved = true`.
+3. **Route user**: "Outline processed. Run `/clear` then `/intuition-assemble` to build the specialist team and begin the detail phase."
 
-### Route User
+## TRANSITION 2.5v9: ASSEMBLE → DETAIL
 
-"Discovery processed. Planning brief saved to `{context_path}planning_brief.md`. Run `/clear` then `/intuition-plan` to create a structured plan."
+v9 mode only. Triggers when outline is complete, `{context_path}team_assignment.json` exists, and detail has not started. This means assemble has finished and the team is ready.
 
-## TRANSITION 2: PLANNING → DESIGN (Initial Setup)
+### Protocol
 
-### Read Outputs
+1. **Read team assignment**: Read `{context_path}team_assignment.json`. Extract specialist_assignments, execution_order, and producer_assignments.
 
-Read: `{context_path}plan.md`
+2. **Read specialist profiles**: For each specialist in specialist_assignments, read their profile to get `display_name` and `domain`.
 
-### Extract Design Items
+3. **Determine first specialist**: From execution_order phase 1, pick the first specialist alphabetically (or the only one if solo).
 
-From the plan, find "Design Recommendations" section. Extract all items flagged for design with rationale and task numbers. If no section exists, assess tasks yourself and present to user.
+4. **Generate detail brief**: Write `{context_path}detail_brief.md` with:
 
-### Extract and Structure
+```markdown
+# Detail Brief
 
-From the plan: new architectural decisions → `docs/project_notes/decisions.md`, risks/dependencies → include in brief, planning work → `docs/project_notes/issues.md`.
+## Current Specialist
+- **Name**: {specialist name}
+- **Display Name**: {display_name from profile}
+- **Domain**: {domain from profile}
+- **Profile Path**: {absolute path to the specialist profile file}
 
-### Present Design Items to User
+## Assigned Tasks
+{For each task assigned to this specialist:}
+### Task {task_id}: {title}
+- **Depth**: {depth}
+- **Description**: {from plan}
+- **Acceptance Criteria**: {from plan}
+- **Dependencies**: {from plan}
 
-Use AskUserQuestion:
-- Header: "Design Items"
-- Question: List each flagged item with rationale
-- Options: "All recommended items need design" / "Some items — let me specify" / "None — skip design, go straight to engineering"
+## Known Research
+{Extract from outline.md the sections relevant to THIS specialist's domain and assigned tasks:}
+{- Section 2 (Discovery Summary) — full content, always include}
+{- Section 4 (Risk Analysis) — risks relevant to this specialist's tasks}
+{- Section 7 (Architectural Decisions) — decisions touching this specialist's domain}
+{- Any other outline sections that contain research findings relevant to the assigned tasks}
+{Omit sections with no relevance to this specialist. If the outline has no research relevant to this specialist, write "No prior research overlaps with this specialist's domain."}
 
-If "Some items," follow up. If "None," use Transition 2B.
+## Prior Blueprints
+None (first specialist in execution order)
 
-### Generate Design Brief
+## Outline Context
+{Relevant content from outline.md Section 10, if present}
 
-Write `{context_path}design_brief.md` for the FIRST item with these sections:
-- **Current Item** (name + description)
-- **Plan Context** (1-2 paragraphs)
-- **Task Details** (task numbers, description, acceptance criteria, dependencies)
-- **Design Rationale** (why flagged)
-- **Constraints**
-- **Design Queue** (all items with status)
-- **References** (plan path, discovery path)
+## Detail Queue
+{All specialists with status:}
+- [in_progress] {first specialist display_name}
+- [pending] {second specialist display_name}
+- [pending] ...
+```
 
-### Update State
+5. **Update state**:
+   - Set `status` to `"detail"`
+   - Set `detail.started` to `true`, `detail.completed` to `false`
+   - Set `detail.team_assignment` to `"team_assignment.json"`
+   - Populate `detail.specialists` array from specialist_assignments. Each entry:
+     - `name`: specialist name
+     - `tasks`: task list from assignment
+     - `status`: `"pending"` (except first specialist: `"in_progress"`)
+     - `stage`: `"stage1"`
+     - `stage1_path`: null
+     - `decisions_path`: null
+     - `blueprint_path`: null
+   - Set `detail.current_specialist` to the first specialist name
+   - Set `detail.execution_phase` to `1`
 
-Update active context: set `status` to `"design"`, mark `planning.completed = true` with timestamp and `approved = true`, set `design.started = true`, populate `design.items` array with all confirmed items, set `design.current_item` to first item, mark first item status `"in_progress"`.
+6. **Route user**: "Team assignment processed. Detail brief prepared for **[First Specialist Display Name]**. Run `/clear` then `/intuition-detail` to begin specialist consultation."
 
-### Route User
+## TRANSITION 3v9: SPECIALIST → SPECIALIST (Next Specialist)
 
-"Plan processed. Design brief prepared for **[First Item Name]**. Run `/clear` then `/intuition-design` to begin design exploration."
+v9 mode only. Triggers when the current specialist's blueprint is complete and more specialists remain.
 
-## TRANSITION 2B: PLANNING → ENGINEER (Skip Design)
+### Protocol
 
-Used when user confirms NO items need design.
+1. **Read completed blueprint**: Read `{context_path}/blueprints/{completed-specialist-name}.md`. Extract: key decisions → `docs/project_notes/decisions.md`, domain facts → `docs/project_notes/key_facts.md`.
 
-### Generate Engineering Brief
+2. **Update specialist status**: In `detail.specialists`, mark the completed specialist as `status: "completed"`, `stage: "done"`, set `blueprint_path` to the blueprint file path.
 
-Write `{context_path}engineering_brief.md` with these sections:
-- **Plan Summary** (1-2 paragraphs)
-- **Objective**
-- **Discovery Context** (brief reminder)
-- **Task Summary** (task list with brief descriptions)
-- **Known Risks** (with mitigations)
-- **References** (plan path, discovery path)
+3. **Determine next specialist**: Check `detail.execution_order` from `{context_path}/team_assignment.json`. Within the current `execution_phase`, find the next specialist with `status: "pending"`. If all specialists in the current phase are complete, advance `execution_phase` and pick the first pending specialist in the next phase.
 
-### Update State
+4. **Check dependencies**: Read `team_assignment.json` dependencies array. If the next specialist has `reads_blueprint_from` entries, verify those blueprints exist. If any dependency blueprint is missing, skip to the next eligible specialist or halt if none are ready.
 
-Update active context: set `status` to `"engineering"`, mark `planning.completed = true` with timestamp and `approved = true`, set `design.started = false`, `design.completed = false`, `design.items = []`, set `engineering.started = true`.
+5. **Generate detail brief for next specialist**: Overwrite `{context_path}/detail_brief.md` with:
+   - **Current Specialist**: name, display_name, domain (from next specialist's profile)
+   - **Assigned Tasks**: task details from outline
+   - **Specialist Profile Path**: absolute path to the next specialist's profile
+   - **Known Research**: same extraction as Transition 2.5v9 — outline sections relevant to this specialist's domain and tasks (Section 2 always, Sections 4/7 filtered by relevance). Omit sections with no relevance.
+   - **Prior Blueprints**: paths to ALL completed blueprints in `{context_path}/blueprints/` (the next specialist may need to reference them)
+   - **Outline Context**: section 10 content
+   - **Detail Queue**: all specialists with status (completed/in_progress/pending)
 
-### Route User
+6. **Update state**: Set `detail.current_specialist` to next specialist name, mark next specialist `status: "in_progress"`, `stage: "stage1"`. Update `detail.execution_phase` if advanced.
 
-"Plan processed. No design items flagged. Engineering brief saved to `{context_path}engineering_brief.md`. Run `/clear` then `/intuition-engineer` to create code specs."
+7. **Route user**: "[Completed Specialist] blueprint complete. Detail brief updated for **[Next Specialist Display Name]** ([N] of [total], [remaining] remaining). Run `/clear` then `/intuition-detail` to continue."
 
-## TRANSITION 3: DESIGN → DESIGN (Next Item)
+## TRANSITION 4v9: DETAIL → BUILD (Conflict Check + Completeness Gate)
 
-### Read Outputs
+v9 mode only. Triggers when ALL specialists in `detail.specialists` have `status: "completed"`.
 
-Read:
-- `{context_path}design_spec_[completed_item].md`
-- Current `.project-memory-state.json`
+### Protocol
 
-### Extract and Structure
+1. **Extract from all blueprints**: For each blueprint in `{context_path}/blueprints/*.md`, extract decisions → `docs/project_notes/decisions.md`, key facts → `docs/project_notes/key_facts.md`.
 
-From completed spec: decisions → `docs/project_notes/decisions.md`, key facts → `docs/project_notes/key_facts.md`, design work → `docs/project_notes/issues.md`.
+2. **Conflict detection**: Spawn a haiku Task subagent to scan all blueprints:
+   - **Prompt**: "Read all blueprint files in `{context_path}/blueprints/`. Compare them for: contradictory decisions (same field/resource specified differently), overlapping file modifications (multiple blueprints targeting the same file with conflicting changes), inconsistent interface assumptions (one blueprint expects an API that another defines differently), and duplicated work (two blueprints specifying the same deliverable). Write findings to `{context_path}/blueprint-conflicts.md`. If no conflicts found, write 'No conflicts detected.' to the file."
+   - If conflicts found → present to user via AskUserQuestion, ask how to resolve. Do NOT proceed to build until resolved or user explicitly accepts the conflicts.
 
-### Determine Next Item
+3. **Completeness gate**: For each blueprint, verify:
+   - Section 8 "Open Items" is empty (or contains only `[VERIFY]` / execution-time items)
+   - All 9 mandatory sections are present and non-empty
+   - Acceptance Mapping section addresses every acceptance criterion from the plan
+   - Producer Handoff section references a valid producer
+   - If any blueprint fails → report the specific failures, do NOT proceed to build.
 
-Find next item with status `"pending"` in `design.items`. If none remain, proceed to Transition 4.
+4. **Generate build brief**: Write `{context_path}/build_brief.md` with:
+   - **Plan Summary** (1-2 paragraphs)
+   - **Objective**
+   - **Team Summary**: specialists involved, blueprint count, producer assignments
+   - **Blueprint Index**: each blueprint with specialist, tasks covered, producer, output format
+   - **Conflict Check**: results (clean or resolved conflicts)
+   - **Quality Gates**: security review, domain specialist reviews, cross-cutting reviews
+   - **Known Risks**: aggregated from blueprints
+   - **References**: plan path, all blueprint paths, team_assignment.json path
 
-### Update Design Brief
+5. **Update state**: Set `status` to `"building"`, mark `detail.completed = true` with timestamp, set `build.started = true`.
 
-Overwrite `{context_path}design_brief.md` for the next item with these sections:
-- **Current Item** (name + description)
-- **Plan Context**
-- **Task Details**
-- **Design Rationale**
-- **Prior Design Context** (relevant prior design decisions)
-- **Constraints** (updated with prior design decisions)
-- **Design Queue** (show completed, current, pending items)
-- **References** (plan path, completed spec paths)
+6. **Route user**: "All blueprints complete. Conflict check [passed/resolved]. Build brief saved to `{context_path}/build_brief.md`. Run `/clear` then `/intuition-build` to begin production."
 
-### Update State
+## TRANSITION 3: DESIGN → DESIGN (Next Item)
 
-Update active context's `design.items`: mark completed item as `"completed"` with `spec_file`, mark next item as `"in_progress"`, set `design.current_item` to next item.
+v8 mode only. Read `{context_path}design_spec_[completed_item].md` and current state. Extract from completed spec: decisions → `decisions.md`, key facts → `key_facts.md`, design work → `issues.md`. Find next `"pending"` item in `design.items`. If none remain, proceed to Transition 4.
 
-### Route User
+Overwrite `{context_path}design_brief.md` for the next item with: Current Item (name + description), Outline Context, Task Details, Design Rationale, Prior Design Context, Constraints (updated with prior decisions), Design Queue (completed/current/pending), References (outline path, completed spec paths).
 
-"[Previous Item] design complete. Design brief updated for **[Next Item Name]** ([N] of [total], [remaining] remaining). Run `/clear` then `/intuition-design` to continue."
+Update state: mark completed item `"completed"` with `spec_file`, mark next item `"in_progress"`, set `design.current_item`. Route: "[Previous Item] design complete. Design brief updated for **[Next Item Name]** ([N] of [total], [remaining] remaining). Run `/clear` then `/intuition-design` to continue."
 
 ## TRANSITION 4: DESIGN → ENGINEER
 
-Triggers when ALL design items have status `"completed"` or `"skipped"`.
+v8 mode only. Triggers when ALL design items are `"completed"` or `"skipped"`. Read all `{context_path}design_spec_*.md` and `outline.md`. Extract from specs: decisions → `decisions.md`, key facts → `key_facts.md`, design work → `issues.md`.
 
-### Read Outputs
+Write `{context_path}engineering_brief.md` with: Outline Summary (1-2 paragraphs), Objective, Discovery Context, Design Specifications (list each spec; include "Engineer MUST read these specs before creating code specs for flagged tasks"), Task Summary (mark tasks with design specs), Known Risks, References (outline, discovery, design spec paths).
 
-Read all design specs: `{context_path}design_spec_*.md`
-Read: `{context_path}plan.md`
+Update state: set `status` to `"engineering"`, mark `design.completed = true` with timestamp, set `engineering.started = true`. Route: "All design specs processed. Engineering brief saved to `{context_path}engineering_brief.md`. Run `/clear` then `/intuition-engineer` to create code specs."
 
-### Extract and Structure
+## TRANSITION 5: ENGINEER → BUILD
 
-From design specs: decisions → `docs/project_notes/decisions.md`, key facts → `docs/project_notes/key_facts.md`, design work → `docs/project_notes/issues.md`.
+Read `{context_path}code_specs.md` and `outline.md`. Extract: engineering decisions → `decisions.md`, implementation approach facts → `key_facts.md`.
 
-### Generate Engineering Brief
+Write `{context_path}build_brief.md` with: Outline Summary (1-2 paragraphs), Objective, Code Specs Summary (task count, key decisions — 1 line each), Required User Steps, Quality Gates (security review, tests, code review), Known Risks, References (outline, code_specs, design spec paths if any).
 
-Write `{context_path}engineering_brief.md` with these sections:
-- **Plan Summary** (1-2 paragraphs)
-- **Objective**
-- **Discovery Context** (brief reminder)
-- **Design Specifications** (list each spec with one-line summary; include: "Engineer MUST read these specs before creating code specs for flagged tasks.")
-- **Task Summary** (list tasks, mark tasks with design specs)
-- **Known Risks** (with mitigations)
-- **References** (plan path, discovery path, design spec paths)
+Update state: set `status` to `"building"`, mark `engineering.completed = true` with timestamp, set `build.started = true`. Route: "Code specs processed. Build brief saved to `{context_path}build_brief.md`. Run `/clear` then `/intuition-build` to begin implementation."
 
-### Update State
+## TRANSITION 6.5v9: BUILD → TEST
 
-Update active context: set `status` to `"engineering"`, mark `design.completed = true` with timestamp, set `engineering.started = true`.
+v9 mode only. Triggers when build completes and `team_assignment.json` contains at least one `producer_assignments` entry with `producer == "code-writer"`.
 
-### Route User
+### Protocol
 
-"All design specs processed. Engineering brief saved to `{context_path}engineering_brief.md`. Run `/clear` then `/intuition-engineer` to create code specs."
+1. **Read build_report.md**: Extract files modified, task results, deviations from blueprints.
 
-## TRANSITION 5: ENGINEER → BUILD
+2. **Extract to memory files**: Same extraction as Transition 6 — bugs → `bugs.md`, lessons/deviations → `key_facts.md`, work completed → `issues.md`. Do NOT mark build as the final step.
 
-### Read Outputs
+3. **Generate test brief**: Write `{context_path}/test_brief.md`:
 
-Read: `{context_path}code_specs.md`
-Read: `{context_path}plan.md`
+```markdown
+# Test Brief
 
-### Extract and Structure
+## Build Summary
+- **Status**: [from build_report]
+- **Tasks completed**: [count and list]
+- **Files modified**: [list from build_report]
 
-From code specs: engineering decisions → `docs/project_notes/decisions.md`, key facts about implementation approach → `docs/project_notes/key_facts.md`.
+## Code Producers Used
+[For each producer_assignments entry where producer == "code-writer":]
+- **Specialist**: [specialist name]
+- **Tasks**: [task IDs]
+- **Output files**: [from build_report]
 
-### Generate Build Brief
+## Acceptance Criteria
+[For each code-writer task, extract acceptance criteria from outline.md]
 
-Write `{context_path}build_brief.md` with these sections:
-- **Plan Summary** (1-2 paragraphs)
-- **Objective**
-- **Code Specs Summary** (task count, key engineering decisions — 1 line each)
-- **Required User Steps** (from code_specs.md — things the user must do manually)
-- **Quality Gates** (security review, tests, code review)
-- **Known Risks** (from code specs risk notes)
-- **References** (plan path, code_specs path, design spec paths if any)
+## Decision Log References
+- Specialist decision logs: [paths to {context_path}/scratch/*-decisions.json]
+- Project decisions: docs/project_notes/decisions.md
 
-### Update State
+## Blueprint References
+[Paths to blueprints for code-writer tasks in {context_path}/blueprints/]
 
-Update active context: set `status` to `"building"`, mark `engineering.completed = true` with timestamp, set `build.started = true`.
+## Specialist Test Recommendations
+[From build_report "Test Deliverables Deferred" section — any test specs/files that specialists recommended but build skipped. Include the blueprint source for each so test can read the full context.]
 
-### Route User
+| Blueprint Source | Deferred File | Description |
+|-----------------|---------------|-------------|
+| [specialist-name.md] | [file path] | [what the specialist recommended] |
 
-"Code specs processed. Build brief saved to `{context_path}build_brief.md`. Run `/clear` then `/intuition-build` to begin implementation."
+[If build_report has no "Test Deliverables Deferred" section or it says "No test deliverables found", write "No specialist test recommendations."]
 
-## TRANSITION 6: BUILD → COMPLETE
+## Known Issues
+[From build_report — any issues, deviations, or flagged items]
+```
 
-### Read Outputs
+4. **Update state**: Set `status` to `"testing"`, mark `build.completed = true` with timestamp, set `test.started = true`.
 
-Read `{context_path}/build_report.md` — REQUIRED. Contains task outcomes, files modified, verification results, and any deviations from specs. If missing, warn the user that build may not have completed properly, then proceed with what's available.
+5. **Route**: "Build complete. Code was produced — test phase needed. Run `/clear` then `/intuition-test`."
 
-### Extract and Structure
+## TRANSITION 7: TEST → COMPLETE
 
-From the build report:
-- Bugs found or issues encountered → `docs/project_notes/bugs.md`
-- Lessons learned or deviations → `docs/project_notes/key_facts.md`
-- Work completed → `docs/project_notes/issues.md`
+Triggers when `context_workflow.status == "testing"` and `workflow.test.completed == true`.
 
-### Git Commit Offer
+### Protocol
 
-Check if a `.git` directory exists at the project root (use Bash: `test -d .git && echo "yes" || echo "no"`).
+1. **Read test_report.md**: Read `{context_path}/test_report.md`. If missing, warn user but proceed with build_report only.
 
-If git repo exists, use AskUserQuestion:
-```
-Question: "Build complete. Would you like to commit the changes?"
-Header: "Git Commit"
-Options:
-- "Yes — commit and push"
-- "Yes — commit only (no push)"
-- "No — skip git"
-```
+2. **Extract to memory files**: Implementation fixes → `docs/project_notes/bugs.md`, test coverage insights → `docs/project_notes/key_facts.md`, escalated issues → `docs/project_notes/issues.md`.
+
+3. **Fall through to Transition 6 completion protocol**: Proceed with the full Transition 6 protocol below (build_report reading, generated specialist saving, git commit offer, state updates). When coming from test, also read test_report.md during the completion extraction and mark `test.completed = true` with timestamp.
+
+## TRANSITION 6: BUILD → COMPLETE
 
-If user approves commit:
-1. Run `git status` to see changed files
-2. Run `git add` for files listed in the build report's "Files Modified" section. Cross-reference with `git status` to catch any files the report missed.
-3. Run `git commit` with a descriptive message summarizing the build
-4. If user chose push: run `git push`
+This transition also serves as the completion protocol for Transition 7 fallthrough. When coming from test (status == "testing"), also read `{context_path}/test_report.md` and include test results in memory extraction. Mark `test.completed = true` with timestamp if applicable. When coming from build with no code-writer (v9) or any v8 build, mark `test.skipped = true`.
 
-If no git repo or user skips: proceed without git operations.
+Read `{context_path}/build_report.md` — REQUIRED (warn user if missing, proceed with what's available). Extract: bugs → `bugs.md`, lessons/deviations → `key_facts.md`, work completed → `issues.md`.
 
-### Update State
+**Save Generated Specialists to User Pool:** Check if `{context_path}/generated-specialists/` directory exists (Glob: `{context_path}generated-specialists/*/*.specialist.md`). If any `.specialist.md` files are found, for EACH file:
+1. Read the file's YAML frontmatter to extract `display_name` and `name`.
+2. Use AskUserQuestion with header "Save Generated Specialist":
+   - Question: "The specialist **[display_name]** was generated during this workflow. Save it to your personal library for future projects?"
+   - Options: "Yes — save to ~/.claude/specialists/" / "No — discard (session-only)"
+3. If "Yes": Create the target directory and copy the file via Bash: `mkdir -p ~/.claude/specialists/{name} && cp "{source_path}" ~/.claude/specialists/{name}/{name}.specialist.md`. Log: "Saved **[display_name]** to `~/.claude/specialists/{name}/`."
+4. If "No": Skip. Log: "Skipped **[display_name]** (session-only)."
 
-Update active context: set `status` to `"complete"`, mark `build.completed = true` with timestamp.
+This step runs only once per completed build, and only if generated specialists exist. If the glob returns no results, skip this step entirely.
 
-### Route User
+**Git Commit Offer:** Check for `.git` directory (Bash: `test -d .git`). If git repo exists, use AskUserQuestion with header "Git Commit", options: "Yes — commit and push" / "Yes — commit only (no push)" / "No — skip git". If approved: `git status`, `git add` files from build report's "Files Modified" (cross-reference with status), `git commit` with descriptive message, optionally `git push`. Skip if no repo or user declines.
 
-"Workflow cycle complete for [context display name]. Run `/clear` then `/intuition-start` to see your project status and decide what's next."
+Update state: set `status` to `"complete"`, mark `build.completed = true` with timestamp. Route: "Workflow cycle complete for [context display name]. Run `/clear` then `/intuition-start` to see your project status and decide what's next."
 
 ## MEMORY FILE FORMATS
 
@@ -462,15 +497,22 @@ All shared memory files live at `docs/project_notes/` (never context_path).
 
 ## EDGE CASES
 
-- **Missing discovery_output.json**: Extract insights from discovery_brief.md manually.
+- **Missing prompt_output.json**: Extract insights from prompt_brief.md manually.
 - **Poor output quality**: Process as-is. Note concerns in brief. Do NOT fix outputs.
-- **New constraints from planning**: Update key_facts.md, create ADR if architectural.
+- **New constraints from outline**: Update key_facts.md, create ADR if architectural.
 - **Interrupted handoff**: Check what's updated, continue from there, don't duplicate.
 - **Corrupted state**: Infer phase from existing files. Ask user to confirm.
 - **Design item skipped mid-loop**: Mark as `"skipped"`, proceed to next. Note in engineering brief.
-- **No Design Recommendations in plan**: Present tasks to user, ask if any need design. If none, use 2B.
-- **Plan revision after design started**: Alert user. Ask whether to continue or re-evaluate.
+- **No Design Recommendations in outline**: Present tasks to user, ask if any need design. If none, use 2B.
+- **Outline revision after design started**: Alert user. Ask whether to continue or re-evaluate.
 - **Missing code_specs.md at Transition 5**: Tell user to run `/intuition-engineer` first.
+- **v9 outline detected but no assemble run yet**: Route to `/intuition-assemble`.
+- **v9 specialist dependency blueprint missing**: Skip to next eligible specialist. If none are eligible, halt and ask user.
+- **v9 conflict detection finds issues**: Present all conflicts, ask user to resolve before build. Do not auto-resolve.
+- **v9 completeness gate fails**: Report exact failures per blueprint. User must fix blueprints (re-run detail) before build.
+- **v9 build with no code-writer**: Skip test, mark `test.skipped = true`, direct to Transition 6 completion.
+- **Test report missing at Transition 7**: Warn user, proceed with build report only for memory extraction.
+- **Test skipped by user**: Set `test.skipped = true`, `test.completed = true`, proceed to completion.
 
 ## VOICE