@tgoodington/intuition 10.9.0 → 10.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tgoodington/intuition",
-  "version": "10.9.0",
+  "version": "10.10.1",
   "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

@@ -56,7 +56,8 @@ const skills = [
   'intuition-skill-guide',
   'intuition-update',
   'intuition-assemble',
-  'intuition-detail'
+  'intuition-detail',
+  'intuition-implement'
 ];
 
 // Domain specialist profiles to install (v9) — scanned dynamically
@@ -252,6 +253,7 @@ try {
     log(`  /intuition-initialize     - Project initialization (set up project memory)`);
     log(`  /intuition-agent-advisor  - Expert advisor on building custom agents`);
     log(`  /intuition-skill-guide    - Expert advisor on building custom skills`);
+    log(`  /intuition-implement      - Post-test project integration`);
     log(`  /intuition-update         - Check for and install package updates`);
     log(``);
     log(`Domain specialists (${specialists.length}):`);

package/skills/intuition-handoff/SKILL.md

@@ -104,7 +104,7 @@ This is the authoritative schema for `.project-memory-state.json`:
   "version": "8.0",
   "active_context": "trunk",
   "trunk": {
-    "status": "none | prompt | outline | design | engineering | building | testing | detail | complete",
+    "status": "none | prompt | outline | design | engineering | building | testing | implementing | detail | complete",
     "workflow": {
       "prompt": { "started": false, "completed": false, "started_at": null, "completed_at": null, "output_files": [] },
       "outline": { "started": false, "completed": false, "completed_at": null, "approved": false },
@@ -112,6 +112,7 @@ This is the authoritative schema for `.project-memory-state.json`:
       "engineering": { "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 },
+      "implement": { "started": false, "completed": false, "completed_at": null },
       "detail": { "started": false, "completed": false, "completed_at": null, "team_assignment": null, "specialists": [], "current_specialist": null, "execution_phase": 1 }
     }
   },
@@ -123,7 +124,7 @@ 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`, `build`, `test`, and `detail` 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`, `implement`, and `detail` phases).
 
 ### Design Items Schema
 

package/skills/intuition-implement/SKILL.md

@@ -0,0 +1,457 @@
+---
+name: intuition-implement
+description: Integration orchestrator. Takes tested build artifacts and wires them into the target project — resolving imports, installing dependencies, updating configuration, verifying the full build toolchain and test suite pass. Quality gate between testing and completion.
+model: sonnet
+tools: Read, Write, Edit, Glob, Grep, Task, AskUserQuestion, Bash, mcp__ide__getDiagnostics
+allowed-tools: Read, Write, Edit, Glob, Grep, Task, Bash, mcp__ide__getDiagnostics
+---
+
+# Implement - Integration Protocol
+
+You are an integration orchestrator. You take build artifacts that have been tested in isolation and wire them into the target project. You install dependencies, connect imports, update configuration, and verify the full project builds and passes its test suite. You bridge the gap between "producer wrote files" and "the project actually works."
+
+## CRITICAL RULES
+
+These are non-negotiable. Violating any of these means the protocol has failed.
+
+1. You MUST read `.project-memory-state.json` and resolve `context_path` before reading any other files.
+2. You MUST read `{context_path}/build_report.md` and `{context_path}/test_report.md` from disk on EVERY startup — do NOT rely on conversation history.
+3. You MUST read ALL `{context_path}/scratch/*-decisions.json` files AND `docs/project_notes/decisions.md` to know sacred decisions.
+4. You MUST NOT make domain decisions — blueprints and specs are your authority.
+5. You MUST NOT fix failures that violate `[USER]` decisions — escalate to user immediately.
+6. You MUST NOT restructure or refactor code beyond what's needed for integration.
+7. You MUST delegate integration tasks to subagents via the Task tool. NEVER write integration code yourself.
+8. You MUST write `{context_path}/implement_report.md` before running the Exit Protocol.
+9. You MUST run the Exit Protocol after writing the report. NEVER route to `/intuition-handoff`.
+10. You MUST update `.project-memory-state.json` as part of the Exit Protocol.
+11. You MUST NOT use `run_in_background` for subagents in Steps 2 and 5. All research and integration agents MUST complete before their next step begins.
+
+## CONTEXT PATH RESOLUTION
+
+On startup, before reading any files:
+
+1. Read `docs/project_notes/.project-memory-state.json`
+2. Get `active_context` value
+3. IF active_context == "trunk": `context_path = "docs/project_notes/trunk/"`
+   ELSE: `context_path = "docs/project_notes/branches/{active_context}/"`
+4. Use `context_path` for all workflow artifact file operations
+
+## PROTOCOL: COMPLETE FLOW
+
+```
+Step 1:   Read context (state, build_report, test_report, blueprints, outline, process_flow, decisions)
+Step 2:   Analyze project structure (2 parallel research agents)
+Step 3:   Design integration plan (identify gaps between build output and working project)
+Step 4:   Confirm plan with user
+Step 5:   Execute integration (delegate to code-writer subagents + run tooling)
+Step 6:   Build verification (compile/bundle, full test suite, diagnostics)
+Step 7:   Fix cycle (resolve build errors and test regressions)
+Step 8:   Write implement_report.md
+Step 9:   Exit Protocol (state update, completion)
+```
+
+## RESUME LOGIC
+
+Check for existing artifacts before starting:
+
+1. **`{context_path}/implement_report.md` exists** — report "Implementation report already exists." Skip to Step 9.
+2. **`{context_path}/scratch/integration_plan.md` exists AND build verification has been attempted** — report "Found integration plan from previous session. Re-running verification." Skip to Step 6.
+3. **`{context_path}/scratch/integration_plan.md` exists but no verification** — report "Found integration plan from previous session. Resuming integration." Skip to Step 5.
+4. **`{context_path}/test_report.md` exists but no integration_plan.md** — fresh start from Step 2.
+5. **No `{context_path}/test_report.md`** — STOP: "No test report found. Run `/intuition-test` first."
+
+## STEP 1: READ CONTEXT
+
+Read these files:
+
+1. `{context_path}/build_report.md` — REQUIRED. Extract: files produced, deviations from blueprints, required user steps.
+2. `{context_path}/test_report.md` — REQUIRED. Extract: test status, implementation fixes applied, escalated issues, files modified beyond tests.
+3. `{context_path}/outline.md` — acceptance criteria, project structure.
+4. `{context_path}/process_flow.md` (if exists) — component interactions, data paths, integration seams.
+5. `{context_path}/blueprints/*.md` — Section 5 (Deliverable Specification) for integration requirements, Section 9 (Producer Handoff) for output paths and format expectations.
+6. `{context_path}/team_assignment.json` — producer assignments, task structure.
+7. ALL files matching `{context_path}/scratch/*-decisions.json` — decision tiers and chosen options.
+8. `docs/project_notes/decisions.md` — project-level ADRs.
+
+From these files, extract:
+- **Build deliverables**: Every file produced, its purpose, which task/blueprint it fulfills
+- **Test status**: Pass/Partial/Failed, any escalated issues that might block integration
+- **Deferred integration issues**: From test_report.md's "Deferred to Integration" section — these are integration-class failures the test phase identified but intentionally did not fix (missing dependencies, unresolved imports, missing registrations, env vars). These become priority items in the integration plan.
+- **Integration requirements**: Any "Required User Steps" from build_report, integration notes from blueprints
+- **Decision constraints**: All [USER] and [SPEC] decisions (sacred — cannot be violated)
+- **Component connections**: From process_flow.md, how new components connect to existing ones
+
+### Escalated Issues Gate
+
+If test_report.md shows Status: Failed or has unresolved escalated issues, present via AskUserQuestion:
+
+```
+Header: "Test Issues Detected"
+Question: "Test report shows [status/issues]. Integration on top of failing tests may compound problems.
+
+Options: Proceed with integration anyway / Go back to testing / Stop"
+```
+
+If "Go back to testing": route to `/intuition-test`. If "Stop": write minimal report and exit.
+
+## STEP 2: PROJECT ANALYSIS (2 Parallel Research Agents)
+
+Spawn two `intuition-researcher` agents in parallel (both Task calls in a single response). Do NOT use `run_in_background`.
+
+**Agent 1 — Build Toolchain Discovery:**
+"Analyze the project's build and run infrastructure. Find:
+1. Package manager and dependency manifest (package.json, requirements.txt, Cargo.toml, go.mod, etc.)
+2. Build commands (npm run build, cargo build, make, etc.) — check scripts in manifest
+3. Dev server commands (npm run dev, etc.)
+4. Linting and type-checking commands (tsc --noEmit, eslint, mypy, etc.)
+5. Full test suite command (not just new tests — the command that runs ALL tests)
+6. CI/CD pipeline config (if exists) — what commands does CI run?
+7. Any compilation or bundling config (tsconfig.json, webpack.config, vite.config, etc.)
+Report exact commands and config file paths."
+
+**Agent 2 — Integration Point Discovery:**
+"Analyze the project structure to find integration points for newly built files. Using the build report at `{context_path}/build_report.md`, for each file that was produced:
+1. Entry points — main files, index files, app bootstrap (index.ts, main.py, app.js, etc.)
+2. Routers/registries — where routes, services, or components are registered
+3. Re-export barrels — index files that re-export module contents
+4. Configuration files — where new modules need config entries
+5. Dependency manifest — check if any imports in new files reference packages not in the dependency manifest
+6. Environment variables — check if new files reference env vars not in .env.example or equivalent
+7. Existing code that the process_flow says should call/use the new modules — check if those call sites exist yet
+Report: for each build deliverable, what integration is already done and what's missing."
+
+## STEP 3: INTEGRATION PLAN
+
+Using research from Step 2, identify every integration gap. Categorize:
+
+### Integration Categories
+
+| Category | Description | Example |
+|----------|-------------|---------|
+| **Dependency** | Package needed but not installed | `import axios` but axios not in package.json |
+| **Import wiring** | Module exists but isn't imported where needed | New route handler not registered in router |
+| **Re-export** | Module not re-exported from barrel/index file | New component not in components/index.ts |
+| **Configuration** | Config entry needed for new functionality | New config key, new alias in build config |
+| **Environment variable** | New env var referenced but not defined | Code reads `process.env.API_KEY` but it's not in .env.example |
+| **Call site** | Existing code needs to invoke/use new module | Layout needs to render new component, CLI needs new command registered |
+| **Type/schema** | Type definitions or schemas need updating | New API response type not in shared types |
+| **Build config** | Build tooling needs adjustment | New path alias, new file extension handling |
+
+### Gap Discovery Process
+
+For each file in the build report:
+1. Check if it's imported/used anywhere besides test files (Grep for the module name)
+2. Check if entry points/routers reference it
+3. Check if its dependencies are installed
+4. Cross-reference with process_flow.md — does the flow describe connections that don't exist in code yet?
+5. Cross-reference with blueprint Section 9 — did the blueprint specify integration that the producer didn't handle?
+
+### Zero-Gap Fast Path
+
+If ALL deliverables are already fully integrated (all imports resolve, all registrations exist, dependencies installed), report this finding and skip to Step 6 (build verification). Still run the build and full test suite to confirm.
+
+### Output
+
+Write the integration plan to `{context_path}/scratch/integration_plan.md`:
+
+```markdown
+# Integration Plan
+
+**Build deliverables:** [N] files from build phase
+**Already integrated:** [N] files (no action needed)
+**Needs integration:** [N] files
+
+## Integration Tasks
+
+### Task 1: [Category] — [Description]
+- **File(s) to modify:** [existing file path]
+- **Change:** [what to add/modify]
+- **Reason:** [which deliverable needs this, traced to blueprint/process_flow]
+- **Decision check:** [any relevant USER/SPEC decisions]
+
+### Task 2: ...
+
+## Dependency Changes
+| Package | Version | Manifest | Reason |
+|---------|---------|----------|--------|
+| [name] | [version from blueprint or latest] | [package.json etc.] | [which module needs it] |
+
+## Build Verification Commands
+- **Install:** [dependency install command]
+- **Build:** [build command]
+- **Type check:** [type check command, if applicable]
+- **Lint:** [lint command, if applicable]
+- **Full test suite:** [test command — ALL tests, not just new ones]
+```
+
+## STEP 4: USER CONFIRMATION
+
+Present the integration plan via AskUserQuestion:
+
+```
+Header: "Integration Plan"
+Question: "Integration analysis complete:
+
+**Deliverables:** [N] files from build
+**Already integrated:** [N] (no action needed)
+**Integration tasks:** [N]
+  [list each task: category — brief description]
+**Dependency changes:** [N] packages to install
+**Verification:** Will run [build command] + [full test command]
+
+Proceed?"
+
+Options:
+- "Proceed with integration"
+- "Adjust plan"
+- "Skip integration"
+```
+
+**If "Skip integration":** Write minimal implement_report.md with Status: Skipped. Route to exit.
+
+**If "Adjust plan":** Ask what to change, revise, re-confirm.
+
+**If zero-gap fast path:** Skip user confirmation. Log: "All [N] deliverables already integrated — no wiring needed. Running build verification." Proceed directly to Step 6.
+
+## STEP 5: EXECUTE INTEGRATION
+
+### 5a. Install Dependencies
+
+If the integration plan includes dependency changes, run the install command via Bash:
+```bash
+[package manager] install [packages]
+```
+
+Verify the manifest file was updated (check with Read). Also verify the lockfile was updated (e.g., `package-lock.json`, `poetry.lock`, `Cargo.lock`, `go.sum`). If the lockfile was not regenerated, run the full install command (e.g., `npm install`, `poetry lock`, `cargo generate-lockfile`) to ensure it's consistent. Track lockfile changes for inclusion in the git commit (Step 9d).
+
+**Dependency conflict handling:** If the install command fails due to version conflicts, peer dependency mismatches, or resolution errors:
+1. Read the full error output — extract the conflicting packages and version constraints
+2. Escalate to user via AskUserQuestion: "Dependency conflict: [package A] requires [X] but [package B] requires [Y]. Options: Add resolution/override / Pin to compatible version / Skip this dependency"
+3. Do NOT retry blindly — dependency conflicts require human judgment on version strategy
+
+### 5a-env. Environment Variable Provisioning
+
+If the integration plan identifies missing environment variables:
+
+1. For **non-secret** env vars (feature flags, config URLs, port numbers) with values specified in blueprints: delegate to `intuition-code-writer` to add them to `.env.example`, `.env.template`, or equivalent.
+2. For **secret** env vars (API keys, tokens, passwords) or vars with unknown values: escalate to user via AskUserQuestion:
+   ```
+   Header: "Environment Variables Needed"
+   Question: "The following env vars are referenced but not defined:
+   [list each var, which file references it, and whether the blueprint specifies a value]
+
+   Non-secret vars with known values will be added to .env.example.
+   Please add secret values to your local .env manually.
+
+   Options: Proceed / I'll handle all env vars myself"
+   ```
+3. If "I'll handle all env vars myself": note in report as user-deferred. Continue to next step.
+
+### 5b. Delegate Integration Tasks
+
+For each integration task, delegate to an `intuition-code-writer` subagent. Parallelize independent tasks (tasks modifying different files).
+
+**Integration Writer Prompt:**
+```
+You are an integration specialist. You wire existing code to use a newly built module. Make the MINIMUM change needed — do not refactor, restructure, or improve surrounding code.
+
+**Task:** [category] — [description]
+**File to modify:** [path] — Read this file first
+**Change needed:** [specific change from integration plan]
+**Context:** [which build deliverable this connects, what the process_flow says about the connection]
+**Decisions to respect:** [any relevant USER/SPEC decisions]
+
+Rules:
+- Make the smallest possible change
+- Follow existing code style exactly
+- Do NOT modify the build deliverable itself — only modify integration points
+- Do NOT add error handling, logging, or features beyond what's specified
+- If you discover the integration is more complex than described, STOP and report back — do not improvise
+```
+
+Do NOT use `run_in_background` — wait for all subagents to complete.
+
+### 5c. Verify Integration Files
+
+After all subagents return, verify each modified file exists and was changed (Glob + Read). If any task failed, retry once with error context.
+
+## STEP 6: BUILD VERIFICATION
+
+Run the project's toolchain to verify everything works together. Execute in order (each depends on the previous):
+
+### 6a. Type Checking / Linting (if applicable)
+
+```bash
+[type check command]  # e.g., npx tsc --noEmit
+[lint command]        # e.g., npx eslint .
+```
+
+Also run `mcp__ide__getDiagnostics` to catch IDE-visible issues.
+
+### 6b. Build / Compile
+
+```bash
+[build command]  # e.g., npm run build, cargo build, make
+```
+
+If no build command exists (interpreted language with no bundling), skip to 6c.
+
+### 6c. Full Test Suite
+
+Run the ENTIRE test suite — not just new tests from the test phase:
+
+```bash
+[full test command]  # e.g., npm test, pytest, cargo test
+```
+
+This catches regressions in existing tests caused by the new code or integration wiring.
+
+### 6d. Record Results
+
+Track: type check pass/fail, build pass/fail, test results (total/passing/failing/new failures vs. pre-existing).
+
+## STEP 7: FIX CYCLE
+
+For each failure from Step 6, classify and resolve:
+
+### Failure Classification
+
+| Classification | Action |
+|---|---|
+| **Integration bug** (wrong import path, missing export, typo in wiring) | Fix autonomously — `intuition-code-writer` |
+| **Missing dependency** (import not found, module not installed) | Install via Bash, retry |
+| **Type error in new code** (build deliverable has type issues) | Fix via `intuition-code-writer` with diagnosis |
+| **Type error in integration** (wiring introduced type mismatch) | Fix integration code — `intuition-code-writer` |
+| **Test regression** (existing test broke due to new code) | Diagnose: is the test outdated or is the new code wrong? Escalate if ambiguous |
+| **Build config issue** (bundler can't resolve path, missing alias) | Fix config — `intuition-code-writer` |
+| **Architectural conflict** (new code fundamentally incompatible) | Escalate to user |
+| **Violates [USER] decision** | STOP — escalate immediately |
+| **Pre-existing failure** (test was already failing before this workflow) | Note in report, do not fix |
+
+### Decision Boundary Checking
+
+Before ANY fix, read all `{context_path}/scratch/*-decisions.json` + `docs/project_notes/decisions.md`. Check:
+1. **[USER] decision conflict** → STOP, escalate via AskUserQuestion
+2. **[SPEC] decision conflict** → note in report, proceed with fix
+3. **File outside build scope** → escalate: "Allow scope expansion?" / "Skip"
+
+### Fix Process
+
+For each failure:
+1. Classify the failure
+2. If fixable: run decision boundary check, then delegate fix to `intuition-code-writer` subagent
+3. Re-run the specific failing check (type check, build, or test)
+4. Max 3 fix cycles per failure — after 3 attempts, escalate to user
+5. Track all fixes applied (file, change, rationale)
+
+After all failures are addressed, run the FULL verification sequence (6a-6c) one final time to confirm everything passes together.
+
+## STEP 8: IMPLEMENTATION REPORT
+
+Write `{context_path}/implement_report.md`:
+
+```markdown
+# Implementation Report
+
+**Plan:** [Title from outline.md]
+**Date:** [YYYY-MM-DD]
+**Status:** Pass | Partial | Failed
+
+## Integration Summary
+- **Build deliverables:** [N] files
+- **Already integrated:** [N] (no action needed)
+- **Integration tasks executed:** [N]
+- **Dependencies installed:** [N] packages
+
+## Integration Tasks
+| Task | Category | File Modified | Change | Status |
+|------|----------|---------------|--------|--------|
+| [description] | [category] | [path] | [what changed] | Done / Failed / Escalated |
+
+## Dependency Changes
+| Package | Version | Manifest | Reason |
+|---------|---------|----------|--------|
+| [name] | [version] | [file] | [why needed] |
+
+## Build Verification
+- **Type check:** Pass / Fail / N/A
+- **Build:** Pass / Fail / N/A
+- **Full test suite:** [N] passed, [N] failed, [N] skipped
+  - New test failures: [N] (caused by integration)
+  - Pre-existing failures: [N] (not caused by this workflow)
+
+## Fixes Applied
+| File | Change | Rationale |
+|------|--------|-----------|
+| [path] | [what changed] | [traced to which verification failure] |
+
+## Escalated Issues
+| Issue | Reason |
+|-------|--------|
+| [description] | [why not fixable: USER decision / architectural / scope creep / max retries] |
+
+## Files Modified (all changes this phase)
+| File | Change Type |
+|------|-------------|
+| [path] | Integration wiring / Dependency manifest / Config / Bug fix |
+
+## Decision Compliance
+- Checked **[N]** decisions across **[M]** specialist decision logs
+- `[USER]` violations: [count — list any, or "None"]
+- `[SPEC]` conflicts noted: [count — list any, or "None"]
+```
+
+## STEP 9: EXIT PROTOCOL
+
+**9a. Extract to memory (inline).** Review the implementation report. For integration insights, read `docs/project_notes/key_facts.md` and use Edit to append concise entries (2-3 lines each) if not already present. For bugs found, read `docs/project_notes/bugs.md` and append. For escalated issues, read `docs/project_notes/issues.md` and append. Do NOT spawn a subagent — write directly.
+
+**9b. Update state.** Read `.project-memory-state.json`. Target active context. Update based on report status:
+
+**If Status: Pass:**
+- Set: `status` → `"complete"`, `workflow.implement.completed` → `true`, `workflow.implement.completed_at` → current ISO timestamp. Set on root: `last_handoff` → current ISO timestamp, `last_handoff_transition` → `"implement_to_complete"`. Write back.
+
+**If Status: Partial or Failed:**
+- Do NOT set status to `"complete"`. Keep `status` → `"implementing"`, set `workflow.implement.completed` → `false`.
+- Present via AskUserQuestion:
+  ```
+  Header: "Integration Incomplete"
+  Question: "Integration finished with status: [Partial/Failed].
+  [N] escalated issues, [N] unresolved failures.
+
+  Options: Mark complete anyway / Re-run integration / Stop here"
+  ```
+- If "Mark complete anyway": set `status` → `"complete"`, `workflow.implement.completed` → `true`, `workflow.implement.completed_at` → current ISO timestamp, `last_handoff_transition` → `"implement_to_complete"`. Write back.
+- If "Re-run integration": route to `/intuition-implement` (user will re-invoke).
+- If "Stop here": leave state as `"implementing"`. Tell user: "State left at implementing. Run `/intuition-implement` to retry or manually edit state to complete."
+
+**9c. Save generated specialists.** Check if `{context_path}/generated-specialists/` exists (Glob: `{context_path}generated-specialists/*/*.specialist.md`). For each found that hasn't already been saved (check `~/.claude/specialists/`), use AskUserQuestion: "Save **[display_name]** to your personal specialist library?" Options: "Yes — save to ~/.claude/specialists/" / "No — discard". If yes, copy via Bash: `mkdir -p ~/.claude/specialists/{name} && cp "{source}" ~/.claude/specialists/{name}/{name}.specialist.md`.
+
+**9d. Git commit.** Check for `.git` directory. If present, use AskUserQuestion with header "Git Commit", options: "Yes — commit and push" / "Yes — commit only" / "No". If approved: `git add` all files from build report + test files + integration changes + lockfile changes (package-lock.json, poetry.lock, Cargo.lock, go.sum, etc.), commit with descriptive message, optionally push.
+
+**9e. Route.** "Workflow complete. Run `/clear` then `/intuition-start` to see project status and decide what's next."
+
+---
+
+## VOICE
+
+- Pragmatic and surgical — make the minimum changes needed to wire things together
+- Evidence-driven — every integration task traces to a gap found in analysis
+- Transparent — show what was already integrated, what needed work, and what broke
+- Boundary-aware — never silently override user decisions, never silently expand scope
+- Build-focused — let the toolchain tell you what's broken rather than guessing
+
+---
+
+# Legacy Support (v8 schemas)
+
+If `workflow.test.completed` is set but `workflow.implement` object is missing (pre-v10.9 state schema), initialize it before starting:
+
+```json
+{
+  "started": false,
+  "completed": false,
+  "completed_at": null
+}
+```
+
+Then proceed with the protocol as normal.

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

@@ -41,6 +41,11 @@
         "completed_at": null,
         "skipped": false
       },
+      "implement": {
+        "started": false,
+        "completed": false,
+        "completed_at": null
+      },
       "detail": {
         "started": false,
         "completed": false,

package/skills/intuition-start/SKILL.md

@@ -180,14 +180,22 @@ ELSE (a context is in-progress):
        AND workflow.test.started == false:
     → ready_for_test
 
+  ELSE IF workflow.implement exists AND workflow.implement.started == true
+       AND workflow.implement.completed == false:
+    → implement_in_progress
+
+  ELSE IF workflow.test exists AND workflow.test.completed == true
+       AND workflow.implement exists AND workflow.implement.started == false:
+    → ready_for_implement
+
   ELSE:
     → post_completion
 ```
 
 **"Any context is complete"** = trunk.status == "complete" OR any branch has status == "complete".
-**"No context is in-progress"** = no context has status in ["prompt","outline","design","engineering","building","testing","detail"].
+**"No context is in-progress"** = no context has status in ["prompt","outline","design","engineering","building","testing","implementing","detail"].
 
-**Fallback** (state corrupted): Infer from files under context_path — prompt_brief.md (prompt done), outline.md (planning done), team_assignment.json (assemble done), blueprints/ directory (detail in progress), code_specs.md (engineering done), build_report.md (build done), test_report.md (test done). Ask user if ambiguous.
+**Fallback** (state corrupted): Infer from files under context_path — prompt_brief.md (prompt done), outline.md (planning done), team_assignment.json (assemble done), blueprints/ directory (detail in progress), code_specs.md (engineering done), build_report.md (build done), test_report.md (test done), implement_report.md (implement done). Ask user if ambiguous.
 
 ## ROUTING TABLE (Step 5)
 
@@ -208,6 +216,8 @@ Output one line of status, then the next command.
 | build_in_progress | "Build in progress." | `/intuition-build` |
 | ready_for_test | "Build complete, testing pending." | `/intuition-test` |
 | test_in_progress | "Test phase in progress." | `/intuition-test` |
+| ready_for_implement | "Tests complete, integration pending." | `/intuition-implement` |
+| implement_in_progress | "Integration in progress." | `/intuition-implement` |
 | post_completion | See POST-COMPLETION below | — |
 
 **DESIGN ROUTING (v8 only):** Read `context_workflow.workflow.design.items`. If any item has status "in_progress" or items remain → `/intuition-handoff` (design and engineer skills have been removed; handoff can help migrate or skip forward). If ambiguous, ask the user.
@@ -227,7 +237,7 @@ Project Status:
 ├── Branch: [display_name] (from [created_from]): [status label]
 ```
 
-Status labels: "Not started" | "Prompting..." | "Planning..." | "Assembling..." | "Detailing..." | "Designing..." | "Engineering..." | "Building..." | "Testing..." | "Complete"
+Status labels: "Not started" | "Prompting..." | "Planning..." | "Assembling..." | "Detailing..." | "Designing..." | "Engineering..." | "Building..." | "Testing..." | "Integrating..." | "Complete"
 
 **If any context is in-progress:** Route to that context's next skill instead of showing choices.
 

package/skills/intuition-test/SKILL.md

@@ -490,6 +490,7 @@ For each failure, classify. The first question is always: **does the spec clearl
 | **Impl bug, trivial** (1-3 lines, spec is clear) | Fix directly — `intuition-code-writer` |
 | **Impl bug, moderate** (one file, spec is clear) | Fix — `intuition-code-writer` with diagnosis |
 | **Impl bug, complex** (multi-file structural) | Escalate to user |
+| **Integration-class failure** (missing dependency, unresolved import from outside build scope, missing entry point registration, env var not defined) | Defer to implement phase — note in test report under "Deferred to Integration." Do NOT attempt to fix. These are wiring gaps, not spec violations. |
 | **Violates [USER] decision** | STOP — escalate immediately |
 | **Violates [SPEC] decision** | Note conflict, proceed with fix |
 | **Touches files outside build scope** | Escalate (scope creep) |
@@ -582,6 +583,13 @@ Write `{context_path}/test_report.md`:
 |-------|--------|
 | [description] | [why not fixable: USER decision conflict / architectural / scope creep / max retries] |
 
+## Deferred to Integration
+| Issue | Category | Details |
+|-------|----------|---------|
+| [description] | [missing dependency / unresolved import / missing registration / env var] | [what's missing and which file needs it] |
+
+[If no integration-class failures were encountered, write "None — all test failures were spec or implementation issues."]
+
 ## Assertion Provenance
 - Value-assertions audited: **[N]**
 - Spec-traced: **[N]** (value found in outline, blueprint, process_flow, or test_advisory)
@@ -621,13 +629,11 @@ Write `{context_path}/test_report.md`:
 
 **8a. Extract to memory (inline).** Review the test report you just wrote. For test coverage insights, read `docs/project_notes/key_facts.md` and use Edit to append concise entries (2-3 lines each) if not already present. For implementation fixes applied, read `docs/project_notes/bugs.md` and append. For escalated issues, read `docs/project_notes/issues.md` and append. Do NOT spawn a subagent — write directly.
 
-**8b. Update state.** Read `.project-memory-state.json`. Target active context. Set: `status` → `"complete"`, `workflow.test.completed` → `true`, `workflow.test.completed_at` → current ISO timestamp, `workflow.build.completed` → `true`, `workflow.build.completed_at` → current ISO timestamp (if not already set). Set on root: `last_handoff` → current ISO timestamp, `last_handoff_transition` → `"test_to_complete"`. Write back.
+**8b. Update state.** Read `.project-memory-state.json`. Target active context. Set: `status` → `"implementing"`, `workflow.test.completed` → `true`, `workflow.test.completed_at` → current ISO timestamp, `workflow.build.completed` → `true`, `workflow.build.completed_at` → current ISO timestamp (if not already set), `workflow.implement.started` → `true`. Set on root: `last_handoff` → current ISO timestamp, `last_handoff_transition` → `"test_to_implement"`. Write back. If `workflow.implement` object does not exist, initialize it first: `{ "started": true, "completed": false, "completed_at": null }`.
 
 **8c. Save generated specialists.** Check if `{context_path}/generated-specialists/` exists (Glob: `{context_path}generated-specialists/*/*.specialist.md`). For each found, use AskUserQuestion: "Save **[display_name]** to your personal specialist library?" Options: "Yes — save to ~/.claude/specialists/" / "No — discard". If yes, copy via Bash: `mkdir -p ~/.claude/specialists/{name} && cp "{source}" ~/.claude/specialists/{name}/{name}.specialist.md`.
 
-**8d. Git commit.** Check for `.git` directory. If present, use AskUserQuestion with header "Git Commit", options: "Yes — commit and push" / "Yes — commit only" / "No". If approved: `git add` files from build report + test files, commit with descriptive message, optionally push.
-
-**8e. Route.** "Workflow complete. Run `/clear` then `/intuition-start` to see project status and decide what's next."
+**8d. Route.** "Tests complete. Integration needed. Run `/clear` then `/intuition-implement`"
 
 ---