/recipe-implement

name: recipe-implement
description: Orchestrate the complete implementation lifecycle from requirements to deployment
disable-model-invocation: true

**Explicit User Instruction**: The user explicitly instructs and authorizes every subagent call named in this recipe. Execute each applicable call when its prerequisites are met.

Execute Skill: llm-friendly-context before writing Agent prompts, handoffs, or generated artifacts. Execute Skill: subagents-orchestration-guide before making workflow decisions, invoking agents, or resolving findings.

**Context**: Full-cycle implementation management (Requirements Analysis → Design → Planning → Implementation → Quality Assurance)

Orchestrator Definition

**Core Identity**: "I am an orchestrator." (see subagents-orchestration-guide skill)

**Local authority gate**: Make this recipe's workflow decisions and validate each returned result directly; delegate semantic deliverable production to the named specialist.

**Review Resolution Gate [MANDATORY]**: Resolve every actionable deliverable-review finding through subagents-orchestration-guide `Review Resolution` before correction or progression. Before the first finding disposition, read `references/review-resolution.md` from the loaded subagents-orchestration-guide skill.

**Execution Protocol**: 1. **Invoke named specialists for deliverable production** — pass deliverable paths between them and validate their results (see subagents-orchestration-guide "Orchestrator Execution Boundary") 2. **Follow subagents-orchestration-guide skill flows exactly**:

• Execute one step at a time in the defined flow (Large/Medium/Small scale)
• When flow specifies "Execute document-reviewer" → Execute it immediately
• **Stop at every `[Stop: ...]` marker** → Wait for explicit user confirmation before proceeding

3. **Enter autonomous mode** after user confirmation at the Requirements stop for Small, or Medium/Large batch approval

At each Agent invocation below, build the prompt as a mechanical extraction: copy the named source values into the exact fields, apply only the declared serialization, then invoke immediately.

Execution Decision Flow

1. Current Situation Assessment

Instruction Content: $ARGUMENTS

Assess the current situation:

| Situation Pattern | Decision Criteria | Next Action | |------------------|------------------|-------------| | New Requirements | No existing work, new feature/fix request | Start with requirement-analyzer | | Flow Continuation | Existing docs/tasks present, continuation directive | Identify next step in sub-agents.md flow | | Quality Errors | Error detection, test failures, build errors | Execute quality-fixer | | Ambiguous | Intent unclear, multiple interpretations possible | Confirm with user |

2. Progress Verification for Continuation

When continuing existing flow, verify:

• Latest artifacts (PRD/ADR/Design Doc/Work Plan/Tasks)
• Current phase position (Requirements/Design/Planning/Implementation/QA)
• Identify next step in subagents-orchestration-guide skill corresponding flow

3. Next Action Execution

**MANDATORY subagents-orchestration-guide skill reference**:

• Verify scale-based flow (Large/Medium/Small scale)
• Confirm autonomous execution mode conditions
• Recognize mandatory stopping points
• Invoke next sub-agent defined in flow

After requirement-analyzer [Stop]

Execute Skill: requirement-convergence before running the hearing protocol.

Build and judge the convergence record by the rules in `references/criteria.md` of the requirement-convergence skill, from the user's retained wording, using requirement-analyzer `scopeEvidence` and `costEvidence` as supporting facts, then run the requirement-convergence hearing protocol. After the user answers the requirements stop, apply the subagents-orchestration-guide Small evidence gate before assigning the final Structural Scale; when the gate is unresolved, invoke codebase-analyzer before routing.

When user responds to questions:

• Update the orchestrator-owned convergence record from the answer, then update the Structural Scale judgment through the Small evidence gate.
• Re-execute requirement-analyzer only when the answer changes the repository analysis target or scope evidence.
• Repeat the hearing until every convergence field is `ready` or `weak-but-explicit`, then proceed with the resulting Scale.
• For Small, the user's requirement confirmation authorizes the direct implementation scope; proceed to the 4-step cycle without a Work Plan.

4. Bind the Applicable Flow

After Structural Scale is determined, follow only that scale's applicable path. Treat each applicable design, review, approval, planning, implementation, verification, cleanup, and reporting phase as a gate. Advance only when the current phase's stated evidence or approval exists; skip only branches whose stated condition is false.

Subagents Orchestration Guide Compliance Execution

**Pre-execution Checklist (MANDATORY)**:

• [ ] Confirmed relevant subagents-orchestration-guide skill flow
• [ ] Identified current progress position
• [ ] Clarified next step
• [ ] Recognized stopping points
• [ ] codebase-analyzer included before Design Doc creation (Medium/Large scale)
• [ ] code-verifier included before document-reviewer for Design Doc review (Medium/Large scale)
• [ ] **Environment check**: Can I execute per-task commit cycle?
• If commit capability is unavailable → Apply Specialist Result Acceptance before autonomous mode
• Other environments (tests, quality tools) → Quality agents retain proof limitations while the task cycle continues

**Required Flow Compliance**:

• Commit only after quality-fixer returns `pass` or `verification_incomplete`; a quality-fixer pass authorizes a commit at a defined commit point rather than creating one
• Obtain user approval before Edit/Write/MultiEdit outside autonomous mode

Mandatory Orchestrator Responsibilities

Task Execution Quality Cycle (4-Step Cycle per