codex-workflows 0.1.0

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

@@ -0,0 +1,119 @@
+---
+name: recipe-build
+description: "Execute decomposed backend tasks in autonomous execution mode using task-executor and quality-fixer."
+---
+
+## 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)
+
+**Execution Protocol**:
+1. **Spawn agents for all work** -- your role is to invoke sub-agents, pass data between them, and report results
+2. **Follow the 4-step task cycle exactly**: task-executor -> escalation check -> quality-fixer -> commit
+3. **Enter autonomous mode** when user provides execution instruction with existing task files -- this IS the batch approval
+4. **Scope**: Complete when all tasks are committed or escalation occurs
+
+**CRITICAL**: MUST run 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."
+
+### 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
+
+## Task Execution Cycle (4-Step Cycle)
+
+**MANDATORY EXECUTION CYCLE**: `task-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 agent**: "Execute the task implementation for [task-file-path]"
+3. **CHECK task-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**: "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
+
+- [ ] Task files verified in docs/plans/tasks/
+- [ ] Task execution order identified with dependencies
+- [ ] Environment check completed (commit capability confirmed)
+- [ ] All tasks executed through 4-step cycle (task-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
+Backend implementation phase completed.
+- Task decomposition: Generated under docs/plans/tasks/
+- Implemented tasks: [number] tasks
+- Quality checks: All passed
+- Commits: [number] commits created

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

@@ -0,0 +1,7 @@
+interface:
+  display_name: "recipe-build"
+  short_description: "Autonomous backend task execution with quality gates"
+  default_prompt: "Use $recipe-build to start building: "
+
+policy:
+  allow_implicit_invocation: false

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

@@ -0,0 +1,90 @@
+---
+name: recipe-design
+description: "Execute from requirement analysis to design document creation."
+---
+
+## Required Skills [LOAD BEFORE EXECUTION]
+
+1. [LOAD IF NOT ACTIVE] `documentation-criteria` — document creation rules and templates
+2. [LOAD IF NOT ACTIVE] `implementation-approach` — implementation strategy
+3. [LOAD IF NOT ACTIVE] `subagents-orchestration-guide` — agent coordination and workflow flows
+
+**Context**: Dedicated to the design phase.
+
+## Orchestrator Definition
+
+**Core Identity**: "I am not a worker. I am an orchestrator." (see subagents-orchestration-guide skill)
+
+**Execution Protocol**:
+1. **Spawn agents for all work** -- your role is to invoke sub-agents, pass data between them, and report results
+2. **Follow subagents-orchestration-guide skill design flow exactly**:
+   - Execute: requirement-analyzer -> technical-designer -> document-reviewer -> design-sync
+   - **[STOP — BLOCKING]** At every `[Stop: ...]` marker -> Present status to user for confirmation. **CANNOT proceed until user explicitly confirms.**
+3. **Scope**: Complete when design documents receive approval
+
+**CRITICAL**: MUST execute document-reviewer, design-sync, and all stopping points defined in subagents-orchestration-guide skill flows -- each serves as a quality gate.
+ENFORCEMENT: Skipping any quality gate invalidates the design output.
+
+## Workflow Overview
+
+```
+Requirements -> requirement-analyzer -> [Stop: Scale determination]
+                                             |
+                                     technical-designer -> document-reviewer
+                                             |
+                                        design-sync -> [Stop: Design approval]
+```
+
+## Scope Boundaries
+
+**Included in this skill**:
+- Requirement analysis with requirement-analyzer
+- ADR creation (if architecture changes, new technology, or data flow changes)
+- Design Doc creation with technical-designer
+- Document review with document-reviewer
+- Design Doc consistency verification with design-sync
+
+**Responsibility Boundary**: This skill completes with design document (ADR/Design Doc) approval. Work planning and beyond are outside scope.
+
+Requirements: $ARGUMENTS
+
+Considering the deep impact on design, first engage in dialogue to understand the background and purpose of requirements:
+- What problems do you want to solve?
+- Expected outcomes and success criteria
+- Relationship with existing systems
+
+Once requirements are moderately clarified, analyze with requirement-analyzer and create appropriate design documents according to scale.
+
+MUST clearly present design alternatives and trade-offs.
+
+Execute the process below within design scope.
+
+## Execution Process
+
+### Step 1: Requirement Analysis
+Spawn requirement-analyzer agent: "Analyze the following requirements and determine scale: $ARGUMENTS"
+
+### Step 2: Design Document Creation
+Spawn technical-designer agent: "Create design document based on requirement analysis output. Include architecture decisions, component design, and acceptance criteria."
+
+### Step 3: Document Review
+Spawn document-reviewer agent: "Review the design document created in the previous step. Verify completeness, consistency, and quality."
+
+### Step 4: Consistency Verification
+Spawn design-sync agent: "Verify consistency of the design document with other existing design documents and project constraints."
+
+**Note**: design-sync returns `sync_status: "SKIPPED"` when only 1 Design Doc exists. This is distinct from `NO_CONFLICTS` and MUST be reported as such to the user.
+
+## Completion Criteria
+
+- [ ] Spawned requirement-analyzer and determined scale
+- [ ] Created appropriate design document (ADR or Design Doc) via technical-designer
+- [ ] Spawned document-reviewer and addressed feedback
+- [ ] Spawned design-sync for consistency verification
+- [ ] Obtained user approval for design document
+- [ ] All `[Stop: ...]` markers honored with user confirmation
+
+## Output Example
+Design phase completed.
+- Design document: docs/design/[document-name].md or docs/adr/[document-name].md
+- Approval status: User approved

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

@@ -0,0 +1,7 @@
+interface:
+  display_name: "recipe-design"
+  short_description: "Requirement analysis to design document creation"
+  default_prompt: "Use $recipe-design to start designing: "
+
+policy:
+  allow_implicit_invocation: false

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

@@ -0,0 +1,187 @@
+---
+name: recipe-diagnose
+description: "Investigate problem, verify findings, and derive solutions through structured diagnosis."
+---
+
+## Required Skills [LOAD BEFORE EXECUTION]
+
+1. [LOAD IF NOT ACTIVE] `ai-development-guide` — AI development patterns
+2. [LOAD IF NOT ACTIVE] `coding-rules` — coding standards
+
+**Context**: Diagnosis flow to identify root cause and present solutions
+
+Target problem: $ARGUMENTS
+
+## Orchestrator Definition
+
+**Core Identity**: "I am not a worker. I am an orchestrator."
+
+**Execution Method**:
+- Investigation -> Spawn investigator agent
+- Verification -> Spawn verifier agent
+- Solution derivation -> Spawn solver agent
+
+Orchestrator spawns sub-agents and passes structured data between them.
+
+**Task Registration**: Register execution steps and proceed systematically. Track status for each step.
+
+## Step 0: Problem Structuring (Before spawning investigator)
+
+### 0.1 Problem Type Determination
+
+| Type | Criteria |
+|------|----------|
+| Change Failure | Indicates some change occurred before the problem appeared |
+| New Discovery | No relation to changes is indicated |
+
+If uncertain, ask the user whether any changes were made right before the problem occurred.
+
+### 0.2 Information Supplementation for Change Failures
+
+If the following are unclear, MUST **ask the user** before proceeding:
+- What was changed (cause change)
+- What broke (affected area)
+- Relationship between both (shared components, etc.)
+
+### 0.3 Problem Essence Understanding
+
+Spawn rule-advisor agent: "Identify the essence and required rules for this problem: [Problem reported by user]"
+
+Confirm from rule-advisor output:
+- `taskAnalysis.essence`: Root problem beyond surface symptoms
+- `taskAnalysis.taskType`: Classification of the problem
+- `selectedRules`: Applicable rule sections
+- `warningPatterns`: Patterns to avoid
+
+### 0.4 Reflecting in investigator Prompt
+
+**Include the following in investigator prompt**:
+1. Problem essence (`taskAnalysis.essence`)
+2. Key applicable rules summary (from selectedRules)
+3. Investigation focus (investigationFocus): Convert warningPatterns to "points prone to confusion or oversight in this investigation"
+4. **For change failures, additionally include**:
+   - Detailed analysis of the change content
+   - Commonalities between cause change and affected area
+   - Determination of whether the change is a "correct fix" or "new bug" with comparison baseline selection
+
+## Diagnosis Flow Overview
+
+```
+Problem -> investigator -> verifier -> solver --+
+                 ^                              |
+                 +-- confidence < high ---------+
+                      (max 2 iterations)
+
+confidence=high reached -> Report
+```
+
+**Context Separation**: Pass only structured output to each step. Each step starts fresh with the data only.
+
+## Execution Steps
+
+Register the following and execute:
+
+### Step 1: Investigation (investigator)
+
+Spawn investigator agent: "Comprehensively collect information related to the following phenomenon. Phenomenon: [Problem reported by user]. Problem essence: [taskEssence]. Investigation focus: [investigationFocus]. Applicable rules: [selectedRules summary]."
+
+**Expected output**: Evidence matrix, comparison analysis results, causal tracking results, list of unexplored areas, investigation limitations
+
+### Step 2: Investigation Quality Check
+
+Review investigation output:
+
+**Quality Check** (verify output contains the following):
+- [ ] comparisonAnalysis
+- [ ] causalChain for each hypothesis (reaching stop condition)
+- [ ] causeCategory for each hypothesis
+- [ ] Investigation covering investigationFocus items (when provided)
+
+**If quality insufficient**: MUST re-spawn investigator agent specifying missing items
+ENFORCEMENT: Proceeding to verifier with incomplete investigation data produces unreliable conclusions.
+
+**design_gap Escalation**:
+
+When investigator output contains `causeCategory: design_gap` or `recurrenceRisk: high`:
+1. **[STOP — BLOCKING]** Present design gap findings to user for confirmation. **CANNOT proceed until user explicitly confirms.**
+2. Ask user:
+   "A design-level issue was detected. How should we proceed?"
+   - A: Attempt fix within current design
+   - B: Include design reconsideration
+3. If user selects B, pass `includeRedesign: true` to solver
+
+Proceed to verifier once quality is satisfied.
+
+### Step 3: Verification (verifier)
+
+Spawn verifier agent: "Verify the following investigation results. Investigation results: [Investigation output]"
+
+**Expected output**: Alternative hypotheses (at least 3), Devil's Advocate evaluation, final conclusion, confidence
+
+**Confidence Criteria**:
+- **high**: No uncertainty affecting solution selection or implementation
+- **medium**: Uncertainty exists but resolvable with additional investigation
+- **low**: Fundamental information gap exists
+
+### Step 4: Solution Derivation (solver)
+
+Spawn solver agent: "Derive solutions based on the following verified conclusion. Causes: [verifier's conclusion.causes]. Causes relationship: [causesRelationship: independent/dependent/exclusive]. Confidence: [high/medium/low]."
+
+**Expected output**: Multiple solutions (at least 3), tradeoff analysis, recommendation and implementation steps, residual risks
+
+**Completion condition**: confidence=high
+
+**When not reached**:
+1. Return to Step 1 with uncertainties identified by solver as investigation targets
+2. Maximum 2 additional investigation iterations
+3. After 2 iterations without reaching high, present user with options:
+   - Continue additional investigation
+   - Execute solution at current confidence level
+
+### Step 5: Final Report Creation
+
+**Prerequisite**: confidence=high achieved
+
+After diagnosis completion, report to user in the following format:
+
+```
+## Diagnosis Result Summary
+
+### Identified Causes
+[Cause list from verification results]
+- Causes relationship: [independent/dependent/exclusive]
+
+### Verification Process
+- Investigation scope: [Scope confirmed in investigation]
+- Additional investigation iterations: [0/1/2]
+- Alternative hypotheses count: [Number generated in verification]
+
+### Recommended Solution
+[Solution derivation recommendation]
+
+Rationale: [Selection rationale]
+
+### Implementation Steps
+1. [Step 1]
+2. [Step 2]
+...
+
+### Alternatives
+[Alternative description]
+
+### Residual Risks
+[solver's residualRisks]
+
+### Post-Resolution Verification Items
+- [Verification item 1]
+- [Verification item 2]
+```
+
+## Completion Criteria
+
+- [ ] Spawned investigator and obtained evidence matrix, comparison analysis, and causal tracking
+- [ ] Performed investigation quality check and re-ran if insufficient
+- [ ] Spawned verifier and obtained confidence level
+- [ ] Spawned solver
+- [ ] Achieved confidence=high (or obtained user approval after 2 additional iterations)
+- [ ] Presented final report to user

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

@@ -0,0 +1,7 @@
+interface:
+  display_name: "recipe-diagnose"
+  short_description: "Structured investigation and solution derivation"
+  default_prompt: "Use $recipe-diagnose to investigate: "
+
+policy:
+  allow_implicit_invocation: false

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

@@ -0,0 +1,127 @@
+---
+name: recipe-front-build
+description: "Execute frontend tasks in autonomous execution mode using task-executor-frontend and quality-fixer-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
+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)
+
+**Execution Protocol**:
+1. **Spawn agents for all work** -- your role is to invoke sub-agents, pass data between them, and report results
+2. **Follow the 4-step task cycle exactly**: task-executor-frontend -> escalation check -> quality-fixer-frontend -> commit
+3. **Enter autonomous mode** when user provides execution instruction with existing task files -- this IS the batch approval
+4. **Scope**: Complete when all tasks are committed or escalation occurs
+
+**CRITICAL**: MUST run quality-fixer-frontend before every commit.
+ENFORCEMENT: Commits without quality-fixer-frontend 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"
+
+### 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
+
+## Task Execution Cycle (4-Step Cycle) - Frontend Specialized
+
+**MANDATORY EXECUTION CYCLE**: `task-executor-frontend -> escalation check -> quality-fixer-frontend -> commit`
+
+### Structured Response Specification
+Each sub-agent responds in JSON format:
+- **task-executor-frontend**: status, filesModified, testsAdded, readyForQualityCheck
+- **integration-test-reviewer**: status (approved/needs_revision/blocked), requiredFixes
+- **quality-fixer-frontend**: status, checksPerformed, fixesApplied, approved
+
+### Execution Flow for Each Task
+
+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-frontend agent**: "Task file: docs/plans/tasks/[filename].md Execute frontend implementation"
+3. **CHECK task-executor-frontend 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-frontend agent**: "Execute all frontend quality checks and fixes"
+5. **COMMIT on approval**: After `approved: true` from quality-fixer-frontend -> Execute git commit. Use `changeSummary` for commit message.
+
+**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
+
+- [ ] Task files verified in docs/plans/tasks/
+- [ ] Task execution order identified with dependencies
+- [ ] Environment check completed (commit capability confirmed)
+- [ ] All tasks executed through 4-step cycle (task-executor-frontend -> check -> quality-fixer-frontend -> commit)
+- [ ] System constraint suffix appended to all sub-agent prompts
+- [ ] All quality gates passed
+- [ ] All tasks committed or escalation completed
+
+## Output Example
+Frontend implementation phase completed.
+- Task decomposition: Generated under docs/plans/tasks/
+- Implemented tasks: [number] tasks
+- Quality checks: All passed (Lighthouse, bundle size, tests)
+- Commits: [number] commits created

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

@@ -0,0 +1,7 @@
+interface:
+  display_name: "recipe-front-build"
+  short_description: "Autonomous frontend task execution with quality gates"
+  default_prompt: "Use $recipe-front-build to start building frontend: "
+
+policy:
+  allow_implicit_invocation: false

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

@@ -0,0 +1,90 @@
+---
+name: recipe-front-design
+description: "Execute from requirement analysis to frontend design document creation including UI Spec."
+---
+
+**Context**: Dedicated to the frontend design 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**:
+- Requirement analysis -> performed by requirement-analyzer
+- UI Specification creation -> performed by ui-spec-designer
+- Design document creation -> performed by technical-designer-frontend
+- Document review -> performed by document-reviewer
+
+Orchestrator spawns agents and passes structured data between them.
+
+## Scope Boundaries
+
+**Included in this skill**:
+- Requirement analysis with requirement-analyzer
+- UI Specification creation with ui-spec-designer (prototype code inquiry included)
+- ADR creation (if architecture changes, new technology, or data flow changes)
+- Design Doc creation with technical-designer-frontend
+- Document review with document-reviewer
+
+**Responsibility Boundary**: This skill completes with frontend design document (UI Spec/ADR/Design Doc) approval. Work planning and beyond are outside scope.
+
+Requirements: $ARGUMENTS
+
+## Execution Flow
+
+### Step 1: Requirement Analysis Phase
+Considering the deep impact on design, first engage in dialogue to understand the background and purpose of requirements:
+- What problems do you want to solve?
+- Expected outcomes and success criteria
+- Relationship with existing systems
+
+Once requirements are moderately clarified:
+- Spawn requirement-analyzer agent: "Requirements: [user requirements] Execute requirement analysis and scale determination"
+
+**[STOP -- BLOCKING]** Review requirement analysis results and address question items.
+**CANNOT proceed until user explicitly confirms the requirement analysis.**
+
+### Step 2: UI Specification Phase
+After requirement analysis approval, ask the user about prototype code:
+
+**Ask the user**: "Do you have prototype code for this feature? If so, please provide the path to the code. The prototype will be placed in `docs/ui-spec/assets/` as reference material for the UI Spec."
+
+**[STOP -- BLOCKING]** Wait for user response about prototype code availability.
+**CANNOT proceed until user responds.**
+
+Then create the UI Specification:
+- Spawn ui-spec-designer agent: "Create UI Spec [from PRD at [path] if PRD exists]. [Prototype code is at [user-provided path]. Place prototype in docs/ui-spec/assets/{feature-name}/ | No prototype code available.]"
+- Spawn document-reviewer agent: "doc_type: UISpec target: [ui-spec path] Review for consistency and completeness"
+
+**[STOP -- BLOCKING]** Present UI Spec for user approval.
+**CANNOT proceed until user explicitly approves the UI Spec.**
+
+### Step 3: Design Document Creation Phase
+Create appropriate design documents according to scale determination:
+- For ADR: Spawn technical-designer-frontend agent: "Create ADR for [technical decision]"
+- For Design Doc: Spawn technical-designer-frontend agent: "Create Design Doc based on requirements. UI Spec is at [ui-spec path]. Inherit component structure and state design from UI Spec."
+- Spawn document-reviewer agent: "Review [document path] for consistency and completeness"
+
+**[STOP -- BLOCKING]** Present design alternatives and trade-offs, obtain user approval.
+**CANNOT proceed until user explicitly approves the design document.**
+
+ENFORCEMENT: Every stop point MUST be respected. Skipping user approval invalidates the entire workflow.
+
+## Completion Criteria
+
+- [ ] Requirement analysis completed and approved
+- [ ] UI Specification created and approved
+- [ ] Design document created and approved
+- [ ] All document reviews passed
+
+## Output Example
+Frontend design phase completed.
+- UI Specification: docs/ui-spec/[feature-name]-ui-spec.md
+- Design document: docs/design/[document-name].md or docs/adr/[document-name].md
+- Approval status: User approved

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

@@ -0,0 +1,7 @@
+interface:
+  display_name: "recipe-front-design"
+  short_description: "Frontend requirements to design docs"
+  default_prompt: "Use $recipe-front-design to design a frontend feature: "
+
+policy:
+  allow_implicit_invocation: false