@tgoodington/intuition 8.1.3 → 9.2.1

package/skills/intuition-handoff/references/handoff_core.md

@@ -8,7 +8,7 @@ Each phase produces valuable output. Your job is to:
 1. Extract the valuable insights from that output
 2. Document them properly in project memory
 3. Prepare the next agent with fresh, relevant context
-4. Maintain the flow from discovery → planning → execution
+4. Maintain the flow from discovery → outline → execution
 
 You're the administrative glue that keeps the symphony coordinated.
 
@@ -16,9 +16,9 @@ You're the administrative glue that keeps the symphony coordinated.
 
 As part of every handoff, extract user profile learnings and update the global user profile:
 
-### Discovery → Planning Handoff (User Profile Focus)
+### Discovery → Outline Handoff (User Profile Focus)
 
-**From discovery_output.json**, extract `user_profile_learnings`:
+**From prompt_output.json**, extract `user_profile_learnings`:
 
 ```json
 {
@@ -37,7 +37,7 @@ As part of every handoff, extract user profile learnings and update the global u
 
 **Update `.claude/USER_PROFILE.json`:**
 1. Read existing `.claude/USER_PROFILE.json` (may be empty initially)
-2. Merge in new learnings from `discovery_output.json`:
+2. Merge in new learnings from `prompt_output.json`:
    - If a field is `null` in profile and has value in learnings, add it
    - If field is populated in profile, only overwrite if discovery_confidence is "high"
    - Always update `metadata.last_updated` timestamp
@@ -75,10 +75,10 @@ When invoked, determine which transition is happening:
 
 ```
 IF workflow.discovery.completed == true
-   AND workflow.planning.started == false:
-   → TRANSITION: Discovery → Planning
+   AND workflow.outline.started == false:
+   → TRANSITION: Discovery → Outline
 
-IF workflow.planning.completed == true
+IF workflow.outline.completed == true
    AND workflow.execution.started == false:
    → TRANSITION: Planning → Execution
 
@@ -91,14 +91,14 @@ Check `.project-memory-state.json` to determine current state:
 ```json
 {
   "workflow": {
-    "status": "discovery",  // or "planning", "executing"
+    "status": "discovery",  // or "outline", "executing"
     "discovery": {
       "started": true,
       "completed": true,
       "completed_at": "2025-02-02T...",
-      "output_files": ["discovery_brief.md", "discovery_output.json"]
+      "output_files": ["prompt_brief.md", "prompt_output.json"]
     },
-    "planning": {
+    "outline": {
       "started": false,
       "completed": false
     }
@@ -106,15 +106,15 @@ Check `.project-memory-state.json` to determine current state:
 }
 ```
 
-## Transition 1: Discovery → Planning
+## Transition 1: Discovery → Outline
 
 ### Step 1: Read Outputs
 
 ```
-discovery_brief.md
+prompt_brief.md
   └─ Human-readable summary of discovery
 
-discovery_output.json
+prompt_output.json
   └─ Structured data for handoff:
      {
        "key_facts_to_add": [...],
@@ -127,11 +127,11 @@ discovery_output.json
 
 ### Step 2: Extract and Structure Findings
 
-From `discovery_output.json`, extract:
+From `prompt_output.json`, extract:
 
 **Key Facts** (for key_facts.md):
 ```
-Example from discovery_output.json:
+Example from prompt_output.json:
 {
   "category": "User Base",
   "fact": "Scaling to support 10,000 concurrent users",
@@ -165,7 +165,7 @@ if they represent architectural choices.
 
 **Suggested Decisions** (for decisions.md):
 ```
-discovery_output.json might suggest:
+prompt_output.json might suggest:
 {
   "suggested_decisions": [
     {
@@ -223,7 +223,7 @@ operations, with write operations on primary instance.
 **Update issues.md:**
 - Log the discovery work completed
 - Format: Date - Brief description - Status
-- Include discovery_brief.md link
+- Include prompt_brief.md link
 
 Example:
 ```markdown
@@ -232,7 +232,7 @@ Example:
 - **Status**: Completed
 - **Description**: Explored user base growth, authentication patterns,
   scalability needs
-- **Discovery Brief**: docs/project_notes/discovery_brief.md
+- **Discovery Brief**: docs/project_notes/prompt_brief.md
 - **Key Findings**:
   - Must scale to 10k concurrent users
   - Prefer JWT-based auth
@@ -241,10 +241,10 @@ Example:
 
 ### Step 4: Generate Brief for Magellan
 
-Create a brief that synthesizes discovery for planning. Structure:
+Create a brief that synthesizes discovery for outline. Structure:
 
 ```markdown
-# Planning Brief: [Problem Title]
+# Outline Brief: [Problem Title]
 
 ## Discovery Summary
 [1-2 paragraph summary of what was discovered]
@@ -268,29 +268,29 @@ Create a brief that synthesizes discovery for planning. Structure:
 
 ## Assumptions & Risks
 - Assumption: [X] - Confidence: High/Medium/Low
-- Risk: [Y] - Should be explored during planning
+- Risk: [Y] - Should be explored during outline
 
 ## References
-- Discovery Brief: docs/project_notes/discovery_brief.md
+- Discovery Brief: docs/project_notes/prompt_brief.md
 - Relevant Decisions: ADR-001, ADR-002
 
 ## Notes for Planner
-[Any observations that might help planning]
+[Any observations that might help outline]
 ```
 
-**Store as:** `docs/project_notes/planning_brief.md`
+**Store as:** `docs/project_notes/outline_brief.md`
 
 ### Step 5: Update Workflow State
 
 ```json
 {
   "workflow": {
-    "status": "planning",
+    "status": "outline",
     "discovery": {
       "completed": true,
       "completed_at": "2025-02-02T..."
     },
-    "planning": {
+    "outline": {
       "started": true,
       "started_at": "2025-02-02T..."
     }
@@ -301,27 +301,27 @@ Create a brief that synthesizes discovery for planning. Structure:
 ### Step 6: Suggest Next Step
 
 ```
-"Discovery is now part of project memory. I've created a planning brief
-at docs/project_notes/planning_brief.md.
+"Discovery is now part of project memory. I've created an outline brief
+at docs/project_notes/outline_brief.md.
 
-Ready to create a plan? Run /intuition-plan to have Magellan synthesize
+Ready to create an outline? Run /intuition-outline to have Magellan synthesize
 this discovery into a structured approach."
 ```
 
 ---
 
-## Transition 2: Planning → Execution
+## Transition 2: Outline → Execution
 
 ### Step 1: Read Output
 
 ```
-plan.md (from Magellan)
-  └─ Structured plan with tasks, dependencies, risks
+outline.md (from Magellan)
+  └─ Structured outline with tasks, dependencies, risks
 ```
 
 ### Step 2: Extract Relevant Info
 
-From `plan.md`, identify:
+From `outline.md`, identify:
 
 **Key Task Information:**
 - Task list and structure
@@ -342,8 +342,8 @@ From `plan.md`, identify:
 ### Step 3: Update Memory Files
 
 **Update issues.md:**
-- Log the planning work
-- Link to plan.md
+- Log the outline work
+- Link to outline.md
 
 Example:
 ```markdown
@@ -352,17 +352,17 @@ Example:
 - **Status**: Planned
 - **Description**: Structured plan for implementing JWT-based user
   authentication across API and frontend
-- **Plan**: docs/project_notes/plan.md
+- **Outline**: docs/project_notes/outline.md
 - **Tasks**: 8 tasks identified, ready for execution
 ```
 
 **Update decisions.md (if needed):**
-- If planning revealed new architectural choices
-- Add ADRs for decisions made during planning
+- If outline revealed new architectural choices
+- Add ADRs for decisions made during outline
 
 **Do NOT modify:**
-- key_facts.md (facts don't change, planning doesn't discover new facts)
-- bugs.md (execution finds bugs, not planning)
+- key_facts.md (facts don't change, outline doesn't discover new facts)
+- bugs.md (execution finds bugs, not outline)
 
 ### Step 4: Generate Brief for Faraday
 
@@ -405,8 +405,8 @@ Create a brief for execution. Structure:
 [Reference to existing ADRs that matter for execution]
 
 ## References
-- Full Plan: docs/project_notes/plan.md
-- Discovery Brief: docs/project_notes/discovery_brief.md
+- Full Outline: docs/project_notes/outline.md
+- Discovery Brief: docs/project_notes/prompt_brief.md
 - Relevant Decisions: ADR-001, ADR-002, ...
 
 ## Notes for Executor
@@ -421,7 +421,7 @@ Create a brief for execution. Structure:
 {
   "workflow": {
     "status": "executing",
-    "planning": {
+    "outline": {
       "completed": true,
       "completed_at": "2025-02-02T..."
     },
@@ -436,7 +436,7 @@ Create a brief for execution. Structure:
 ### Step 6: Suggest Next Step
 
 ```
-"Planning is now in project memory. I've created an execution brief
+"Outline is now in project memory. I've created an execution brief
 at docs/project_notes/execution_brief.md with everything Faraday needs.
 
 Ready to execute? Run /intuition-execute to have Faraday coordinate
@@ -485,7 +485,7 @@ implementation."
 **Consequences:**
 [Benefits and trade-offs]
 
-**Discovered During**: Discovery phase (discovery_brief.md)
+**Discovered During**: Discovery phase (prompt_brief.md)
 **Confidence**: High/Medium/Low
 ```
 
@@ -497,7 +497,7 @@ implementation."
 - **Status**: Completed | In Progress | Blocked
 - **Description**: [1-2 line summary]
 - **Discovery Brief**: [link] (if from discovery)
-- **Plan**: [link] (if from planning)
+- **Outline**: [link] (if from outline)
 - **URL**: [link to ticket if external]
 - **Notes**: [any relevant context]
 ```
@@ -506,12 +506,12 @@ implementation."
 
 ## Edge Cases
 
-### What if discovery_output.json doesn't exist?
+### What if prompt_output.json doesn't exist?
 
 ```
-1. Check if discovery_brief.md exists
+1. Check if prompt_brief.md exists
 2. If yes: Read brief manually and extract key insights
-3. Summarize into a simple discovery_output.json structure
+3. Summarize into a simple prompt_output.json structure
 4. Proceed with handoff
 5. Note: Less structured, but handoff still works
 ```
@@ -526,12 +526,12 @@ implementation."
 4. User can request re-discovery if needed
 ```
 
-### What if planning revealed new constraints?
+### What if outline revealed new constraints?
 
 ```
 1. Update key_facts.md with new constraints
 2. Create ADR if it represents architectural choice
-3. Note in issues.md that planning revealed this
+3. Note in issues.md that outline revealed this
 4. Include in execution brief for Faraday's awareness
 ```
 
@@ -565,8 +565,8 @@ Example:
 ✓ decisions.md: Added ADR-005 on database strategy
 ✓ issues.md: Logged discovery work completed
 
-I've created planning_brief.md with everything Magellan needs.
-Ready to plan? Run /intuition-plan"
+I've created outline_brief.md with everything Magellan needs.
+Ready to outline? Run /intuition-outline"
 ```
 
 ---
@@ -575,7 +575,7 @@ Ready to plan? Run /intuition-plan"
 
 Before completing handoff:
 
-- [ ] Detected correct transition (Discovery→Planning or Planning→Execution)
+- [ ] Detected correct transition (Discovery→Outline or Outline→Execution)
 - [ ] Read all necessary output files
 - [ ] Extracted insights without losing information
 - [ ] Updated memory files with proper formatting

package/skills/intuition-initialize/SKILL.md

@@ -15,7 +15,7 @@ You create the `docs/project_notes/` directory structure, initialize memory file
 1. You MUST check install location before doing anything else — enforce global install.
 2. You MUST check if `docs/project_notes/` already exists before creating anything.
 3. You MUST use template files from `references/` directory for all initial content. Read each template with the Read tool, then Write to the target path.
-4. You MUST create `.project-memory-state.json` using the v5.0 schema from `references/state_template.json`. Do NOT use older schemas.
+4. You MUST create `.project-memory-state.json` using the v7.0 schema from `references/state_template.json`. Do NOT use older schemas.
 5. You MUST auto-create all configuration files (CLAUDE.md, INTUITION.md, AGENTS.md, settings, profile) if they do not exist. Do NOT ask — just create them.
 6. You MUST NOT overwrite existing files. If a file already exists, skip it silently.
 7. You MUST NOT invoke other skills. You only set up infrastructure.
@@ -27,7 +27,7 @@ You create the `docs/project_notes/` directory structure, initialize memory file
 Step 0: Check install location — enforce global install
 Step 1: Detect existing setup
 Step 2: Create memory directory and files from templates
-Step 3: Create .project-memory-state.json with v5.0 schema
+Step 3: Create .project-memory-state.json with v7.0 schema
 Step 4: Update CLAUDE.md with workflow protocols
 Step 4.5: Create INTUITION.md framework overview
 Step 5: Create configuration files (AGENTS.md, settings, user profile)
@@ -111,18 +111,18 @@ For each file, use the Read tool to read the template, then use Write to create
 | `references/key_facts_template.md` | `docs/project_notes/key_facts.md` |
 | `references/issues_template.md` | `docs/project_notes/issues.md` |
 
-Do NOT create workflow output files (discovery_brief.md, plan.md, etc.). Those are created by their respective skills.
+Do NOT create workflow output files (prompt_brief.md, plan.md, etc.). Those are created by their respective skills.
 
 ## STEP 3: CREATE STATE FILE
 
 Read `references/state_template.json` and write to `docs/project_notes/.project-memory-state.json`.
 
-The state file uses the v5.0 schema:
+The state file uses the v7.0 schema:
 
 ```json
 {
   "initialized": true,
-  "version": "5.0",
+  "version": "8.0",
   "active_context": "trunk",
   "trunk": {
     "status": "none",
@@ -134,7 +134,7 @@ The state file uses the v5.0 schema:
         "completed_at": null,
         "output_files": []
       },
-      "planning": {
+      "outline": {
         "started": false,
         "completed": false,
         "completed_at": null,
@@ -156,6 +156,21 @@ The state file uses the v5.0 schema:
         "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
       }
     }
   },

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

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