codex-workflows 0.1.0

package/.agents/skills/recipe-front-plan/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: recipe-front-plan
+description: "Create frontend work plan from design document with test skeleton generation."
+---
+
+**Context**: Dedicated to the frontend planning phase.
+
+## Required Skills [LOAD BEFORE EXECUTION]
+
+1. [LOAD IF NOT ACTIVE] `documentation-criteria` -- document quality standards
+2. [LOAD IF NOT ACTIVE] `implementation-approach` -- implementation methodology
+3. [LOAD IF NOT ACTIVE] `subagents-orchestration-guide` -- agent coordination and workflow flows
+
+## Orchestrator Definition
+
+**Core Identity**: "I am not a worker. I am an orchestrator."
+
+**Execution Method**:
+- Test skeleton generation -> performed by acceptance-test-generator
+- Work plan creation -> performed by work-planner
+
+Orchestrator spawns agents and passes structured data between them.
+
+## Scope Boundaries
+
+**Included in this skill**:
+- Design document selection
+- Test skeleton generation with acceptance-test-generator
+- Work plan creation with work-planner
+- Plan approval obtainment
+
+**Responsibility Boundary**: This skill completes with work plan approval.
+
+Create frontend work plan with the following process:
+
+## Execution Process
+
+### Step 1: Design Document Selection
+Check for existence of design documents in docs/design/.
+- Present options if multiple exist (can be specified with $ARGUMENTS)
+
+**[STOP -- BLOCKING]** If no design documents exist, notify user and halt.
+**CANNOT proceed without a design document.**
+
+### Step 2: Test Skeleton Generation
+Spawn acceptance-test-generator agent: "Generate test skeletons from Design Doc at [path]. [UI Spec at [ui-spec path] if exists.]"
+
+### Step 3: Work Plan Creation
+Spawn work-planner agent: "Create work plan from Design Doc at [path]. Integration test file: [path from step 2]. E2E test file: [path from step 2]. Integration tests are created simultaneously with each phase implementation, E2E tests are executed only in final phase."
+
+**[STOP -- BLOCKING]** Interact with user to complete plan and obtain approval for plan content. Clarify specific implementation steps and risks.
+**CANNOT proceed until user explicitly approves the work plan.**
+
+ENFORCEMENT: Plan content MUST be approved before declaring completion. Unapproved plans are invalid.
+
+## Completion Criteria
+
+- [ ] Design document selected
+- [ ] Test skeletons generated
+- [ ] Work plan created
+- [ ] User approved plan content
+
+## Output Example
+Frontend planning phase completed.
+- Work plan: docs/plans/[plan-name].md
+- Status: Approved
+
+Please provide separate instructions for implementation.

package/.agents/skills/recipe-front-plan/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "recipe-front-plan"
+  short_description: "Frontend design doc to work plan with tests"
+  default_prompt: "Use $recipe-front-plan to plan frontend work: "
+
+policy:
+  allow_implicit_invocation: false

package/.agents/skills/recipe-front-review/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: recipe-front-review
+description: "Frontend Design Doc compliance validation with optional auto-fixes using React-specific quality checks."
+---
+
+**Context**: Post-implementation quality assurance for React/TypeScript frontend
+
+## Required Skills [LOAD BEFORE EXECUTION]
+
+1. [LOAD IF NOT ACTIVE] `coding-rules` -- coding standards
+2. [LOAD IF NOT ACTIVE] `testing` -- test strategy and quality gates
+3. [LOAD IF NOT ACTIVE] `ai-development-guide` -- AI development patterns
+
+## Execution Method
+
+- Compliance validation -> performed by code-reviewer
+- Rule analysis -> performed by rule-advisor
+- Fix implementation -> performed by task-executor-frontend
+- Quality checks -> performed by quality-fixer-frontend
+- Re-validation -> performed by code-reviewer
+
+Orchestrator spawns agents and passes structured data between them.
+
+Design Doc (uses most recent if omitted): $ARGUMENTS
+
+## Execution Flow
+
+### 1. Prerequisite Check
+Identify the Design Doc in docs/design/ and check implementation files changed from the default branch (detect via `git symbolic-ref refs/remotes/origin/HEAD` or fall back to current branch diff).
+
+**[STOP -- BLOCKING]** If no Design Doc or implementation files found, notify user and halt.
+**CANNOT proceed without both a Design Doc and implementation files.**
+
+### 2. Execute code-reviewer
+Spawn code-reviewer agent: "Validate Design Doc compliance for [design-doc-path]. Check: acceptance criteria fulfillment, code quality, implementation completeness."
+
+### 3. Verdict and Response
+
+**Criteria (considering project stage)**:
+- Prototype: Pass at 70%+
+- Production: 90%+ recommended
+- Critical items (security, etc.): Required regardless of rate
+
+**Compliance-based response**:
+
+For low compliance (production <90%):
+```
+Validation Result: [X]% compliance
+Unfulfilled items:
+- [item list]
+
+Execute fixes? (y/n):
+```
+
+**[STOP -- BLOCKING]** Wait for user response on whether to execute fixes.
+**CANNOT proceed with auto-fixes without user approval.**
+
+If user selects `y`:
+
+## Pre-fix Metacognition
+**Required flow**: rule-advisor -> task registration -> task-executor-frontend -> quality-fixer-frontend
+
+1. **Spawn rule-advisor agent**: "Analyze fixes needed for [unfulfilled items]. Determine root solutions vs symptomatic treatments."
+2. **Register tasks**: Register work steps. Always include: first "Confirm skill constraints", final "Verify skill fidelity". Create task file -> `docs/plans/tasks/review-fixes-YYYYMMDD.md`
+3. **Spawn task-executor-frontend agent**: "Execute staged auto-fixes for [task-file-path]. Stop at 5 files."
+4. **Spawn quality-fixer-frontend agent**: "Execute all frontend quality checks and confirm quality gate passage"
+5. **Re-validate**: Spawn code-reviewer agent: "Re-validate compliance for [design-doc-path]. Measure improvement."
+
+ENFORCEMENT: Auto-fixes MUST go through quality-fixer-frontend before re-validation. Skipping quality checks invalidates fixes.
+
+### 4. Final Report
+```
+Initial compliance: [X]%
+Final compliance: [Y]% (if fixes executed)
+Improvement: [Y-X]%
+
+Remaining issues:
+- [items requiring manual intervention]
+```
+
+## Auto-fixable Items
+- Simple unimplemented acceptance criteria
+- Error handling additions
+- Contract definition fixes
+- Function splitting (length/complexity improvements)
+
+## Non-fixable Items
+- Fundamental business logic changes
+- Architecture-level modifications
+- Design Doc deficiencies
+
+## Completion Criteria
+
+- [ ] Design Doc compliance validated
+- [ ] Compliance percentage calculated
+- [ ] User informed of results
+- [ ] Fixes executed if requested and approved
+- [ ] Quality gates passed for all fixes
+- [ ] Final compliance re-measured
+
+**Scope**: Design Doc compliance validation and auto-fixes.

package/.agents/skills/recipe-front-review/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "recipe-front-review"
+  short_description: "Frontend Design Doc compliance with React-specific checks"
+  default_prompt: "Use $recipe-front-review to validate frontend: "
+
+policy:
+  allow_implicit_invocation: false

package/.agents/skills/recipe-fullstack-build/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: recipe-fullstack-build
+description: "Execute decomposed fullstack tasks with layer-aware agent routing between backend and frontend executors."
+---
+
+## Required Skills [LOAD BEFORE EXECUTION]
+
+1. [LOAD IF NOT ACTIVE] `coding-rules` -- coding standards
+2. [LOAD IF NOT ACTIVE] `testing` -- test strategy and quality gates
+3. [LOAD IF NOT ACTIVE] `ai-development-guide` -- AI development patterns
+4. [LOAD IF NOT ACTIVE] `subagents-orchestration-guide` -- agent coordination and workflow flows
+
+## Orchestrator Definition
+
+**Core Identity**: "I am not a worker. I am an orchestrator." (see subagents-orchestration-guide skill)
+
+## Required Reference
+
+**MANDATORY**: Read `references/monorepo-flow.md` from subagents-orchestration-guide skill BEFORE proceeding. Follow the Extended Task Cycle and Agent Routing defined there.
+
+ENFORCEMENT: Proceeding without reading monorepo-flow.md invalidates the entire workflow.
+
+## Execution Protocol
+
+1. **Spawn agents for all work** -- your role is to invoke sub-agents, pass data between them, and report results
+2. **Route agents by task filename pattern** (see monorepo-flow.md reference):
+   - `*-backend-task-*` -> task-executor + quality-fixer
+   - `*-frontend-task-*` -> task-executor-frontend + quality-fixer-frontend
+3. **Follow the 4-step task cycle exactly**: executor -> escalation check -> quality-fixer -> commit
+4. **Enter autonomous mode** when user provides execution instruction with existing task files -- this IS the batch approval
+5. **Scope**: Complete when all tasks are committed or escalation occurs
+
+**CRITICAL**: MUST run layer-appropriate quality-fixer before every commit.
+ENFORCEMENT: Commits without quality-fixer approval are invalid and MUST be reverted.
+
+Work plan: $ARGUMENTS
+
+## Pre-execution Prerequisites
+
+### Task File Existence Check
+Check for work plans in docs/plans/ and task files in docs/plans/tasks/.
+
+### Task Generation Decision Flow
+
+Analyze task file existence state and determine the action required:
+
+| State | Criteria | Next Action |
+|-------|----------|-------------|
+| Tasks exist | .md files in tasks/ directory | User's execution instruction serves as batch approval -> Enter autonomous execution immediately |
+| No tasks + plan exists | Plan exists but no task files | Confirm with user -> spawn task-decomposer |
+| Neither exists | No plan or task files | Error: Prerequisites not met |
+
+## Task Decomposition Phase (Conditional)
+
+When task files don't exist:
+
+### 1. User Confirmation
+```
+No task files found.
+Work plan: docs/plans/[plan-name].md
+
+Generate tasks from the work plan? (y/n):
+```
+
+### 2. Task Decomposition (if approved)
+Spawn task-decomposer agent: "Read work plan at docs/plans/[plan-name].md and decompose into atomic tasks. Output: Individual task files in docs/plans/tasks/. Granularity: 1 task = 1 commit = independently executable. Use layer-aware naming: {plan}-backend-task-{n}.md, {plan}-frontend-task-{n}.md based on target file paths."
+
+### 3. Verify Generation
+Verify generated task files exist in docs/plans/tasks/.
+
+## Pre-execution Checklist
+
+- [ ] Confirmed task files exist in docs/plans/tasks/
+- [ ] Identified task execution order (dependencies)
+- [ ] **Environment check**: Can I execute per-task commit cycle?
+  - If commit capability unavailable -> Escalate before autonomous mode
+  - Other environments (tests, quality tools) -> Subagents will escalate
+
+## Agent Routing Table
+
+| Filename Pattern | Executor | Quality Fixer |
+|-----------------|----------|---------------|
+| `*-backend-task-*` | task-executor | quality-fixer |
+| `*-frontend-task-*` | task-executor-frontend | quality-fixer-frontend |
+| `*-task-*` (no layer prefix) | task-executor | quality-fixer (default) |
+
+## Task Execution Cycle (4-Step Cycle)
+
+**MANDATORY EXECUTION CYCLE**: `executor -> escalation check -> quality-fixer -> commit`
+
+For EACH task, YOU MUST:
+1. **Register tasks**: Register work steps. Always include: first "Confirm skill constraints", final "Verify skill fidelity"
+2. **Spawn task-executor or task-executor-frontend agent** (per routing table): "Execute the task implementation for [task-file-path]"
+3. **CHECK executor response**:
+   - `status: "escalation_needed"` or `"blocked"` -> STOP and escalate to user
+   - `testsAdded` contains `*.int.test.ts` or `*.e2e.test.ts` -> Spawn integration-test-reviewer agent: "Review integration tests in [test-files]"
+     - `needs_revision` -> Return to step 2 with `requiredFixes`
+     - `approved` -> Proceed to step 4
+   - `readyForQualityCheck: true` -> Proceed to step 4
+4. **Spawn quality-fixer agent** (layer-appropriate per routing table): "Execute all quality checks and fixes"
+5. **COMMIT on approval**: After `approved: true` from quality-fixer -> Execute git commit
+
+**CRITICAL**: MUST monitor ALL structured responses WITHOUT EXCEPTION and ENSURE every quality gate is passed.
+ENFORCEMENT: Proceeding past a failed quality gate invalidates all subsequent work.
+
+## Sub-agent Invocation Constraints
+
+**MANDATORY suffix for ALL sub-agent prompts**:
+```
+[SYSTEM CONSTRAINT]
+This agent operates within build skill scope. Use orchestrator-provided rules only.
+```
+
+Autonomous sub-agents require scope constraints for stable execution. MUST append this constraint to every sub-agent prompt.
+ENFORCEMENT: Sub-agent prompts missing the constraint suffix MUST be re-issued with the constraint appended.
+
+VERIFY approval status before proceeding. Once confirmed, INITIATE autonomous execution mode.
+
+**[STOP -- BLOCKING]** Upon detecting ANY requirement changes, halt execution immediately.
+**CANNOT proceed until user explicitly confirms the change scope.**
+
+## Completion Criteria
+
+- [ ] monorepo-flow.md read before execution
+- [ ] Task files verified in docs/plans/tasks/
+- [ ] Task execution order identified with dependencies
+- [ ] Environment check completed (commit capability confirmed)
+- [ ] All tasks routed to correct layer-appropriate agents
+- [ ] All tasks executed through 4-step cycle (executor -> check -> quality-fixer -> commit)
+- [ ] System constraint suffix appended to all sub-agent prompts
+- [ ] All quality gates passed
+- [ ] All tasks committed or escalation completed
+
+## Output Example
+Fullstack implementation phase completed.
+- Task decomposition: Generated under docs/plans/tasks/
+- Implemented tasks: [number] tasks (backend: X, frontend: Y)
+- Quality checks: All passed
+- Commits: [number] commits created

package/.agents/skills/recipe-fullstack-build/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "recipe-fullstack-build"
+  short_description: "Layer-aware fullstack task execution with routing"
+  default_prompt: "Use $recipe-fullstack-build to start building fullstack: "
+
+policy:
+  allow_implicit_invocation: false

package/.agents/skills/recipe-fullstack-implement/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: recipe-fullstack-implement
+description: "Orchestrate full-cycle implementation across backend and frontend layers with layer-aware agent routing."
+---
+
+**Context**: Full-cycle fullstack implementation management (Requirements Analysis -> Design (backend + frontend) -> Planning -> Implementation -> Quality Assurance)
+
+## Required Skills [LOAD BEFORE EXECUTION]
+
+1. [LOAD IF NOT ACTIVE] `coding-rules` -- coding standards
+2. [LOAD IF NOT ACTIVE] `testing` -- test strategy and quality gates
+3. [LOAD IF NOT ACTIVE] `ai-development-guide` -- AI development patterns
+4. [LOAD IF NOT ACTIVE] `documentation-criteria` -- document quality standards
+5. [LOAD IF NOT ACTIVE] `implementation-approach` -- implementation methodology
+6. [LOAD IF NOT ACTIVE] `subagents-orchestration-guide` -- agent coordination and workflow flows
+
+## Orchestrator Definition
+
+**Core Identity**: "I am not a worker. I am an orchestrator." (see subagents-orchestration-guide skill)
+
+## Required Reference
+
+**MANDATORY**: Read `references/monorepo-flow.md` from subagents-orchestration-guide skill BEFORE proceeding. Follow the Fullstack Flow defined there instead of the standard single-layer flow.
+
+ENFORCEMENT: Proceeding without reading monorepo-flow.md invalidates the entire workflow.
+
+## Execution Protocol
+
+1. **Spawn agents for all work** -- your role is to invoke sub-agents, pass data between them, and report results
+2. **Follow monorepo-flow.md** for the design phase (multiple Design Docs, design-sync, vertical slicing)
+3. **Follow subagents-orchestration-guide skill** for all other orchestration rules (stop points, structured responses, escalation)
+4. **Enter autonomous mode** only after "batch approval for entire implementation phase"
+
+**CRITICAL**: Execute all steps, sub-agents, and stopping points defined in both the monorepo-flow.md reference and subagents-orchestration-guide skill.
+
+## 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 monorepo-flow.md |
+| Quality Errors | Error detection, test failures, build errors | Execute quality-fixer (layer-appropriate) |
+| Ambiguous | Intent unclear, multiple interpretations possible | Confirm with user |
+
+### 2. Progress Verification for Continuation
+
+When continuing existing flow, verify:
+- Latest artifacts (PRD/ADR/Design Docs/Work Plan/Tasks)
+- Current phase position (Requirements/Design/Planning/Implementation/QA)
+- Identify next step in monorepo-flow.md
+
+### 3. Execute monorepo-flow.md
+
+**Follow monorepo-flow.md step-by-step** for the complete flow from UI Spec through Design Docs through Work Plan. The flow includes:
+- UI Spec creation (with prototype inquiry)
+- Separate Design Docs per layer (technical-designer for backend, technical-designer-frontend for frontend)
+- **Backend Design Doc**: Spawn technical-designer agent
+- **Frontend Design Doc**: Spawn technical-designer-frontend agent (MUST use frontend-specific agent)
+- document-reviewer per Design Doc
+- design-sync for cross-layer consistency
+- Work plan with vertical slicing
+
+All stop points defined in monorepo-flow.md MUST be respected.
+
+### 5. Register All Flow Steps (MANDATORY)
+
+**After scale determination, register all steps of the monorepo-flow.md**:
+- First task: "Confirm skill constraints"
+- Register each step as individual task
+- Mark currently executing step as in_progress
+- **Complete task registration before spawning subagents**
+
+## After requirement-analyzer [Stop]
+
+When user responds to questions:
+- If response matches any `scopeDependencies.question` -> Check `impact` for scale change
+- If scale changes -> Re-execute requirement-analyzer with updated context
+- If `confidence: "confirmed"` or no scale change -> Proceed to next step
+
+## Orchestration Compliance
+
+**Pre-execution Checklist (MANDATORY)**:
+- [ ] Read monorepo-flow.md reference
+- [ ] Confirmed relevant flow steps
+- [ ] Identified current progress position
+- [ ] Clarified next step
+- [ ] Recognized stopping points
+- [ ] **Environment check**: Can I execute per-task commit cycle?
+  - If commit capability unavailable -> Escalate before autonomous mode
+  - Other environments (tests, quality tools) -> Subagents will escalate
+
+**Required Flow Compliance**:
+- Run quality-fixer (layer-appropriate) before every commit
+- Obtain user approval before Edit/Write outside autonomous mode
+
+ENFORCEMENT: Commits without quality-fixer approval are invalid and MUST be reverted.
+
+## Sub-agent Invocation Constraints
+
+**MANDATORY suffix for ALL sub-agent prompts**:
+```
+[SYSTEM CONSTRAINT]
+This agent operates within fullstack-implement skill scope. Use orchestrator-provided rules only.
+```
+
+Autonomous sub-agents require scope constraints for stable execution. MUST append this constraint to every sub-agent prompt.
+ENFORCEMENT: Sub-agent prompts missing the constraint suffix MUST be re-issued with the constraint appended.
+
+## Task Execution Quality Cycle (Filename-Pattern-Based)
+
+**Agent routing by task filename** (see monorepo-flow.md reference):
+```
+*-backend-task-*   -> task-executor + quality-fixer
+*-frontend-task-*  -> task-executor-frontend + quality-fixer-frontend
+```
+
+**Rules**:
+1. Execute ONE task completely before starting next (each task goes through the full 4-step cycle individually, using the correct executor per filename pattern)
+2. Check executor status before quality-fixer (escalation check)
+3. Quality-fixer MUST run after each executor (no skipping)
+4. Commit MUST execute when quality-fixer returns `approved: true` (do not defer to end)
+
+### Test Information Communication
+After acceptance-test-generator execution, when calling work-planner, communicate:
+- Generated integration test file path
+- Generated E2E test file path
+- Explicit note that integration tests are created simultaneously with implementation, E2E tests are executed after all implementations
+
+**[STOP -- BLOCKING]** Upon detecting ANY requirement changes, halt execution immediately.
+**CANNOT proceed until user explicitly confirms the change scope.**
+
+## Completion Criteria
+
+- [ ] monorepo-flow.md read before execution
+- [ ] All flow steps registered
+- [ ] Separate Design Docs created per layer
+- [ ] Design-sync executed for cross-layer consistency
+- [ ] All stop points respected with user approval
+- [ ] All tasks executed through layer-appropriate 4-step cycle
+- [ ] All quality gates passed
+- [ ] All tasks committed or escalation completed
+
+## Execution Method
+
+All work is executed through sub-agents.
+Sub-agent selection follows monorepo-flow.md reference and subagents-orchestration-guide skill.

package/.agents/skills/recipe-fullstack-implement/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "recipe-fullstack-implement"
+  short_description: "Full-cycle cross-layer implementation orchestration"
+  default_prompt: "Use $recipe-fullstack-implement to implement a fullstack feature: "
+
+policy:
+  allow_implicit_invocation: false

package/.agents/skills/recipe-implement/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: recipe-implement
+description: "Orchestrate the complete implementation lifecycle from requirements to deployment."
+---
+
+## Required Skills [LOAD BEFORE EXECUTION]
+
+1. [LOAD IF NOT ACTIVE] `subagents-orchestration-guide` — agent coordination and workflow flows
+2. [LOAD IF NOT ACTIVE] `documentation-criteria` — document creation rules and templates
+
+# Full-Cycle Implementation
+
+$ARGUMENTS
+
+## Orchestrator Definition
+
+**Core Identity**: "I am not a worker. I am an orchestrator." (see subagents-orchestration-guide skill)
+
+**CRITICAL**: MUST execute all steps, sub-agents, and stopping points defined in subagents-orchestration-guide skill flows.
+ENFORCEMENT: Skipping any step or stopping point invalidates the entire workflow output.
+
+## CRITICAL Sub-agent Invocation Constraints
+
+**MANDATORY suffix for ALL sub-agent prompts**:
+```
+[SYSTEM CONSTRAINT]
+This agent operates within implement skill scope. Use orchestrator-provided rules only.
+```
+ENFORCEMENT: Sub-agent prompts missing the constraint suffix MUST be re-issued with the constraint appended.
+
+## Step 1: Requirement Analysis
+
+Spawn requirement-analyzer agent to determine scale and affected layers.
+
+**[STOP — BLOCKING]** Present requirement-analyzer output (scale, affectedLayers, scope) to user for confirmation. **CANNOT proceed until user explicitly confirms.**
+
+When user responds to questions:
+- If response matches any `scopeDependencies.question` -> Check `impact` for scale change
+- If scale changes -> Re-execute requirement-analyzer with updated context
+- If `confidence: "confirmed"` or no scale change -> Proceed to Step 2
+
+## Step 2: Layer-Based Workflow Routing
+
+Based on requirement-analyzer output `affectedLayers`, route to the appropriate workflow:
+
+| affectedLayers | Workflow | Reference |
+|---|---|---|
+| `["backend"]` only | Backend Flow | subagents-orchestration-guide skill (Large/Medium/Small scale) |
+| `["frontend"]` only | Frontend Flow | See Frontend Flow below |
+| `["backend", "frontend"]` | Fullstack Flow | subagents-orchestration-guide `references/monorepo-flow.md` |
+
+---
+
+### Backend Flow
+
+Follow subagents-orchestration-guide skill Large/Medium/Small scale flow exactly. All steps, stopping points, and sub-agent sequencing are defined there.
+
+---
+
+### Frontend Flow
+
+**STEP 1**: Ask user if they have prototype code or UI references to provide.
+
+**STEP 2**: Spawn ui-spec-designer agent → spawn document-reviewer agent.
+**[STOP — BLOCKING]** Present UI Spec for user approval. **CANNOT proceed until user explicitly confirms.**
+
+**STEP 3**: Spawn technical-designer-frontend agent → spawn document-reviewer agent → spawn design-sync agent.
+**[STOP — BLOCKING]** Present Frontend Design Doc for user approval. **CANNOT proceed until user explicitly confirms.**
+
+**STEP 4**: Spawn acceptance-test-generator agent → spawn work-planner agent.
+**[STOP — BLOCKING]** Present Work Plan for user approval. **CANNOT proceed until user explicitly confirms.**
+
+**STEP 5**: Enter guided autonomous execution (see Autonomous Execution Mode below) using task-executor-frontend + quality-fixer-frontend agents.
+
+---
+
+### Fullstack Flow
+
+Follow subagents-orchestration-guide `references/monorepo-flow.md` for the complete cross-layer workflow, including:
+- Separate Design Docs per layer
+- design-sync for cross-layer consistency
+- Vertical slicing in work-planner
+- Layer-aware task execution routing
+
+---
+
+## Autonomous Execution Mode
+
+After user grants "batch approval for entire implementation phase", enter autonomous execution.
+
+### Task Execution Quality Cycle (4-Step Cycle per Task)
+
+**Agent routing by task filename** (for fullstack projects):
+```
+*-backend-task-*   -> Spawn task-executor agent + quality-fixer agent
+*-frontend-task-*  -> Spawn task-executor-frontend agent + quality-fixer-frontend agent
+*-task-* (no layer prefix) -> Spawn task-executor agent + quality-fixer agent (default)
+```
+
+**Per-task cycle** (complete each task before starting next):
+1. Spawn task-executor (or task-executor-frontend) agent: "Implement task [task-file-path]"
+2. Check task-executor response:
+   - `status: escalation_needed` or `blocked` -> Escalate to user
+   - `testsAdded` contains `*.int.test.ts` or `*.e2e.test.ts` -> Spawn integration-test-reviewer agent
+     - `needs_revision` -> Return to step 1 with `requiredFixes`
+     - `approved` -> Proceed to step 3
+   - Otherwise -> Proceed to step 3
+3. Spawn quality-fixer (or quality-fixer-frontend) agent: "Quality check and fixes"
+4. git commit -> Execute on `approved: true`
+
+### Test Information Communication
+After acceptance-test-generator execution, when spawning work-planner, communicate:
+- Generated integration test file path
+- Generated E2E test file path
+- Note: integration tests are created with implementation; E2E tests run after all implementations
+
+## Completion Criteria
+
+- [ ] Requirement analysis completed and user-confirmed
+- [ ] Layer routing determined (backend / frontend / fullstack)
+- [ ] Correct workflow followed per layer routing
+- [ ] All stopping points honored with user confirmation obtained
+- [ ] Quality-fixer spawned before every commit
+- [ ] All tasks committed or escalation completed
+- [ ] System constraint suffix appended to all sub-agent prompts

package/.agents/skills/recipe-implement/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "recipe-implement"
+  short_description: "Requirements to deployment lifecycle"
+  default_prompt: "Use $recipe-implement to start implementing: "
+
+policy:
+  allow_implicit_invocation: false