@devo-bmad-custom/agent-orchestration 1.0.0

package/src/bmm/workflows/3-solutioning/create-architecture/steps/step-06-structure.md

@@ -0,0 +1,186 @@
+# Step 6: Project Structure & Boundaries
+
+**Goal:** Define the complete project structure and architectural boundaries based on all decisions made, creating a concrete implementation guide for AI agents.
+
+**Rules:** Read this entire file before acting. Create a specific, complete project tree — not generic placeholders. Map requirements to specific files and directories. Present [A]/[P]/[C] menu after generating content. Save only when user selects C.
+
+- AUTONOMY OVERRIDE: If you have enough context to answer any discovery questions yourself, DO NOT ask the user. Make expert assumptions, generate the content, display it, and immediately proceed to {nextStepFile} without halting.
+---
+
+## PROJECT STRUCTURE SEQUENCE
+
+### 1. Analyze Requirements Mapping
+
+**From Epics (if available):**
+"Epic: {epic_name} → Lives in {module/directory/service}"
+- User stories within the epic, cross-epic dependencies, shared components needed
+
+**From FR Categories (if no epics):**
+"FR Category: {fr_category_name} → Lives in {module/directory/service}"
+- Related FRs, shared functionality, integration points
+
+### 2. Define Project Directory Structure
+
+**Root configuration files:** Package management, build/dev config, environment files, CI/CD, documentation.
+
+**Source code organization:** Entry points, core structure, feature/module organization, shared utilities, configuration.
+
+**Test organization:** Unit, integration, e2e test locations and structure; test utilities and fixtures.
+
+**Build and distribution:** Output directories, distribution files, static assets, documentation build.
+
+### 3. Define Integration Boundaries
+
+**API boundaries:** External endpoints, internal service boundaries, auth/authorization boundaries, data access layer.
+
+**Component boundaries:** Frontend communication patterns, state management boundaries, service communication, event-driven integration.
+
+**Data boundaries:** Database schema boundaries, data access patterns, caching, external data integration.
+
+### 4. Create Complete Project Tree
+
+Generate a comprehensive, specific directory structure showing all files and directories (not generic placeholders — use actual names from the project):
+
+Example reference structures:
+
+**Next.js Full-Stack:**
+```
+project-name/
+├── README.md
+├── package.json
+├── next.config.js
+├── tailwind.config.js
+├── tsconfig.json
+├── .env.local / .env.example / .gitignore
+├── .github/workflows/ci.yml
+├── src/
+│   ├── app/ (globals.css, layout.tsx, page.tsx)
+│   ├── components/ (ui/, forms/, features/)
+│   ├── lib/ (db.ts, auth.ts, utils.ts)
+│   ├── types/
+│   └── middleware.ts
+├── prisma/ (schema.prisma, migrations/)
+├── tests/ (__mocks__/, components/, e2e/)
+└── public/assets/
+```
+
+**API Backend (NestJS):**
+```
+project-name/
+├── package.json / nest-cli.json / tsconfig.json
+├── .env / .env.example / .gitignore / README.md
+├── src/
+│   ├── main.ts / app.module.ts
+│   ├── config/
+│   ├── modules/ (auth/, users/, common/)
+│   ├── services/ / repositories/ / decorators/
+│   ├── pipes/ / guards/ / interceptors/
+├── test/ (unit/, integration/, e2e/)
+├── prisma/ (schema.prisma, migrations/)
+└── docker-compose.yml
+```
+
+### 5. Map Requirements to Structure
+
+Create explicit mapping from project requirements to specific files/directories:
+
+```
+Epic: User Management
+- Components: src/components/features/users/
+- Services: src/services/users/
+- API Routes: src/app/api/users/
+- Database: prisma/migrations/*users*
+- Tests: tests/features/users/
+
+Authentication System (cross-cutting)
+- Components: src/components/auth/
+- Services: src/services/auth/
+- Middleware: src/middleware/auth.ts
+- Tests: tests/auth/
+```
+
+### 6. Generate Structure Content
+
+```markdown
+## Project Structure & Boundaries
+
+### Complete Project Directory Structure
+
+{{complete_project_tree_with_all_files_and_directories}}
+
+### Architectural Boundaries
+
+**API Boundaries:**
+{{api_boundary_definitions}}
+
+**Component Boundaries:**
+{{component_communication_patterns}}
+
+**Service Boundaries:**
+{{service_integration_patterns}}
+
+**Data Boundaries:**
+{{data_access_patterns}}
+
+### Requirements to Structure Mapping
+
+**Feature/Epic Mapping:**
+{{mapping_of_epics_to_directories}}
+
+**Cross-Cutting Concerns:**
+{{mapping_of_shared_functionality}}
+
+### Integration Points
+
+**Internal Communication:**
+{{how_components_communicate}}
+
+**External Integrations:**
+{{third_party_integration_points}}
+
+**Data Flow:**
+{{how_data_flows_through_architecture}}
+
+### File Organization Patterns
+
+**Configuration Files:** {{location_and_naming}}
+**Source Organization:** {{structure_and_organization}}
+**Test Organization:** {{test_structure}}
+**Asset Organization:** {{static_and_dynamic_assets}}
+
+### Development Workflow Integration
+
+**Development Server:** {{dev_structure}}
+**Build Process:** {{build_structure}}
+**Deployment:** {{deployment_structure}}
+```
+
+### 7. Present Content and Menu
+
+"I've created a complete project structure based on all our architectural decisions.
+
+**Here's what I'll add to the document:**
+[Show complete markdown content]
+
+**What would you like to do?**
+[A] Advanced Elicitation [P] Party Mode [AR] Adversarial Review [PL] Party Mode Loop [AL] Adversarial Review Loop [C] Continue — Save and move to architecture validation"
+
+**Menu handling:**
+- **A:** Read fully and follow: `{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml`. Ask "Accept changes? (y/n)". If yes: update content. Return to this menu.
+- **P:** Read fully and follow: `{project-root}/_bmad/core/workflows/party-mode/workflow.md`. Ask "Accept changes? (y/n)". If yes: update content. Return to this menu.
+- **AR:** Execute `{project-root}/_bmad/core/tasks/review-adversarial-general.xml` — display findings, then redisplay menu.
+- **C:** Append content to `{planning_artifacts}/architecture.md`, update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6]`, then load `{project-root}/_bmad/bmm/workflows/3-solutioning/create-architecture/steps/step-07-validation.md`.
+- **Any other input:** Respond, then redisplay menu.
+
+DO NOT halt after generating the content. Automatically append the content and proceed to {nextStepFile} unless the user explicitly interrupts.
+
+---
+
+## SUCCESS METRICS
+
+- Complete project tree defined with all specific files and directories
+- All architectural boundaries clearly documented
+- Requirements/epics mapped to specific locations
+- Integration points and communication patterns defined
+- Project structure aligned with chosen technology stack
+- Content properly appended and frontmatter updated when C selected

package/src/bmm/workflows/3-solutioning/create-architecture/steps/step-07-validation.md

@@ -0,0 +1,163 @@
+# Step 7: Architecture Validation & Completion
+
+**Goal:** Validate the complete architecture for coherence, completeness, and readiness to guide AI agents through consistent implementation.
+
+**Rules:** Read this entire file before acting. Run comprehensive validation — do not skip checks. Present [A]/[P]/[C] menu after generating validation results. Save only when user selects C.
+
+- AUTONOMY OVERRIDE: If you have enough context to answer any discovery questions yourself, DO NOT ask the user. Make expert assumptions, generate the content, display it, and immediately proceed to {nextStepFile} without halting.
+---
+
+## VALIDATION SEQUENCE
+
+### 1. Coherence Validation
+
+**Decision compatibility:** Do all technology choices work together without conflicts? Are versions compatible? Do patterns align with technology choices? Any contradictory decisions?
+
+**Pattern consistency:** Do implementation patterns support architectural decisions? Are naming conventions consistent across all areas? Do structure patterns align with tech stack? Are communication patterns coherent?
+
+**Structure alignment:** Does the project structure support all architectural decisions? Are boundaries properly defined? Does the structure enable the chosen patterns? Are integration points properly structured?
+
+### 2. Requirements Coverage Validation
+
+**From Epics (if available):** Does every epic have architectural support? Are all user stories implementable with these decisions? Are cross-epic dependencies handled? Any gaps in epic coverage?
+
+**From FRs (if no epics):** Does every functional requirement have architectural support? Are all FR categories covered? Are cross-cutting FRs properly addressed?
+
+**Non-functional requirements:** Performance, security, scalability, and compliance requirements all addressed architecturally?
+
+### 3. Implementation Readiness Validation
+
+**Decision completeness:** All critical decisions documented with versions? Implementation patterns comprehensive? Consistency rules clear and enforceable? Examples provided for major patterns?
+
+**Structure completeness:** Project structure complete and specific? All files and directories defined? Integration points clearly specified? Component boundaries well-defined?
+
+**Pattern completeness:** All potential conflict points addressed? Naming conventions comprehensive? Communication and process patterns fully specified?
+
+### 4. Gap Analysis
+
+**Critical gaps** (block implementation): Missing decisions, incomplete patterns, missing structural elements, undefined integration points.
+
+**Important gaps** (improve quality): Areas needing more specification, patterns that could be more comprehensive.
+
+**Nice-to-have gaps**: Additional patterns, supplementary documentation, tooling recommendations.
+
+### 5. Address Validation Issues
+
+For any issues found, facilitate resolution:
+
+**Critical:** "I found issues that need addressing before implementation: {description}. These could cause implementation problems. How would you like to resolve this?"
+
+**Important:** "A few areas could be improved: {description}. These aren't blocking, but addressing them would make implementation smoother. Should we work on these?"
+
+**Minor:** "Minor suggestions: {description}. Optional refinements — would you like to address any?"
+
+### 6. Generate Validation Content
+
+```markdown
+## Architecture Validation Results
+
+### Coherence Validation ✅
+
+**Decision Compatibility:** {{assessment}}
+**Pattern Consistency:** {{verification}}
+**Structure Alignment:** {{confirmation}}
+
+### Requirements Coverage Validation ✅
+
+**Epic/Feature Coverage:** {{verification}}
+**Functional Requirements Coverage:** {{confirmation}}
+**Non-Functional Requirements Coverage:** {{verification}}
+
+### Implementation Readiness Validation ✅
+
+**Decision Completeness:** {{assessment}}
+**Structure Completeness:** {{evaluation}}
+**Pattern Completeness:** {{verification}}
+
+### Gap Analysis Results
+
+{{gap_analysis_findings_with_priority_levels}}
+
+### Validation Issues Addressed
+
+{{issues_found_and_resolutions}}
+
+### Architecture Completeness Checklist
+
+**✅ Requirements Analysis**
+- [x] Project context thoroughly analyzed
+- [x] Scale and complexity assessed
+- [x] Technical constraints identified
+- [x] Cross-cutting concerns mapped
+
+**✅ Architectural Decisions**
+- [x] Critical decisions documented with versions
+- [x] Technology stack fully specified
+- [x] Integration patterns defined
+- [x] Performance considerations addressed
+
+**✅ Implementation Patterns**
+- [x] Naming conventions established
+- [x] Structure patterns defined
+- [x] Communication patterns specified
+- [x] Process patterns documented
+
+**✅ Project Structure**
+- [x] Complete directory structure defined
+- [x] Component boundaries established
+- [x] Integration points mapped
+- [x] Requirements to structure mapping complete
+
+### Architecture Readiness Assessment
+
+**Overall Status:** READY FOR IMPLEMENTATION
+**Confidence Level:** {{high/medium/low}}
+
+**Key Strengths:** {{list}}
+**Areas for Future Enhancement:** {{areas}}
+
+### Implementation Handoff
+
+**AI Agent Guidelines:**
+- Follow all architectural decisions exactly as documented
+- Use implementation patterns consistently across all components
+- Respect project structure and boundaries
+- Refer to this document for all architectural questions
+
+**First Implementation Priority:** {{starter_template_command_or_first_step}}
+```
+
+### 7. Present Content and Menu
+
+"I've completed a comprehensive validation of your architecture.
+
+**Validation Summary:**
+- ✅ Coherence: All decisions work together
+- ✅ Coverage: All requirements are supported
+- ✅ Readiness: AI agents can implement consistently
+
+**Here's what I'll add to complete the architecture document:**
+[Show complete markdown content]
+
+**What would you like to do?**
+[A] Advanced Elicitation [P] Party Mode [AR] Adversarial Review [PL] Party Mode Loop [AL] Adversarial Review Loop [C] Continue — Complete the architecture"
+
+**Menu handling:**
+- **A:** Read fully and follow: `{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml`. Ask "Accept improvements? (y/n)". If yes: update content. Return to this menu.
+- **P:** Read fully and follow: `{project-root}/_bmad/core/workflows/party-mode/workflow.md`. Ask "Accept changes? (y/n)". If yes: update content. Return to this menu.
+- **AR:** Execute `{project-root}/_bmad/core/tasks/review-adversarial-general.xml` — display findings, then redisplay menu.
+- **C:** Append content to `{planning_artifacts}/architecture.md`, update frontmatter `stepsCompleted: [1, 2, 3, 4, 5, 6, 7]`, then load `{project-root}/_bmad/bmm/workflows/3-solutioning/create-architecture/steps/step-08-complete.md`.
+- **Any other input:** Respond, then redisplay menu.
+
+DO NOT halt after generating the content. Automatically append the content and proceed to {nextStepFile} unless the user explicitly interrupts.
+
+---
+
+## SUCCESS METRICS
+
+- All architectural decisions validated for coherence
+- Complete requirements coverage verified
+- Implementation readiness confirmed
+- All gaps identified and addressed
+- Comprehensive validation checklist completed
+- Content properly appended and frontmatter updated when C selected

package/src/bmm/workflows/3-solutioning/create-architecture/steps/step-08-complete.md

@@ -0,0 +1,38 @@
+# Step 8: Architecture Completion & Handoff
+
+**Goal:** Complete the architecture workflow, celebrate what was accomplished, and guide the user to the implementation phase.
+
+---
+
+## COMPLETION SEQUENCE
+
+### 1. Congratulate the User
+
+Summarize what you built together and genuinely celebrate the achievement — both the thoroughness of the decisions made and the collaboration that produced them.
+
+### 2. Update Document Frontmatter
+
+```yaml
+stepsCompleted: [1, 2, 3, 4, 5, 6, 7, 8]
+workflowType: 'architecture'
+lastStep: 8
+status: 'complete'
+completedAt: '{{current_date}}'
+```
+
+### 3. Next Steps
+
+Architecture complete. Read fully and follow: `{project-root}/_bmad/core/tasks/help.md`
+
+Upon completion, offer to answer any questions about the Architecture Document.
+
+---
+
+## SUCCESS METRICS
+
+- Complete architecture document delivered with all sections
+- All architectural decisions documented and validated
+- Implementation patterns and consistency rules finalized
+- Project structure complete with all files and directories
+- User provided with clear next steps
+- Workflow status properly updated in frontmatter

package/src/bmm/workflows/3-solutioning/create-architecture/workflow.md

@@ -0,0 +1,49 @@
+---
+name: create-architecture
+description: 'Create architecture solution design decisions for AI agent consistency. Use when the user says "lets create architecture" or "create technical architecture" or "create a solution design"'
+---
+
+# Architecture Workflow
+
+**Goal:** Create comprehensive architecture decisions through collaborative step-by-step discovery that ensures AI agents implement consistently.
+
+**Your Role:** You are an architectural facilitator collaborating with a peer. This is a partnership, not a client-vendor relationship. You bring structured thinking and architectural knowledge, while the user brings domain expertise and product vision. Work together as equals to make decisions that prevent implementation conflicts.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **micro-file architecture** for disciplined execution:
+
+- Each step is a self-contained file with embedded rules
+- Sequential progression with user control at each step
+- Document state tracked in frontmatter
+- Append-only document building through conversation
+- You NEVER proceed to a step file if the current step file indicates the user must approve and indicate continuation.
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+
+- `project_name`, `output_folder`, `planning_artifacts`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as system-generated current datetime
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### Paths
+
+- `installed_path` = `{project-root}/_bmad/bmm/workflows/3-solutioning/create-architecture`
+- `template_path` = `{installed_path}/architecture-decision-template.md`
+- `data_files_path` = `{installed_path}/data/`
+
+---
+
+## EXECUTION
+
+Read fully and follow: `{project-root}/_bmad/bmm/workflows/3-solutioning/create-architecture/steps/step-01-init.md` to begin the workflow.
+
+**Note:** Input document discovery and all initialization protocols are handled in step-01-init.md.

package/src/bmm/workflows/3-solutioning/create-epics-and-stories/steps/step-01-validate-prerequisites.md

@@ -0,0 +1,129 @@
+---
+name: 'step-01-validate-prerequisites'
+description: 'Validate required documents exist and extract all requirements for epic and story creation'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/create-epics-and-stories'
+
+# File References
+thisStepFile: './step-01-validate-prerequisites.md'
+nextStepFile: './step-02-design-epics.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{planning_artifacts}/epics.md'
+epicsTemplate: '{workflow_path}/templates/epics-template.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+
+# Template References
+epicsTemplate: '{workflow_path}/templates/epics-template.md'
+---
+
+## Step 0: Load writing-skills
+
+Invoke `writing-skills` now. Do not proceed to Step 1 until writing-skills is loaded.
+
+---
+
+# Step 1: Validate Prerequisites and Extract Requirements
+
+**Goal:** Validate required input documents exist and extract all requirements (FRs, NFRs, additional) needed for epic and story creation.
+
+**Rules:** Read this entire file before acting. Focus only on requirements extraction — do not create epics or stories here.
+
+---
+
+## REQUIREMENTS EXTRACTION PROCESS
+
+### 1. Welcome and Prerequisites
+
+Welcome {user_name} to epic and story creation.
+
+**Required documents:**
+
+1. **PRD.md** — Contains FRs, NFRs, and product scope
+2. **Architecture.md** — Technical decisions, API contracts, data models
+3. **UX Design.md** — Interaction patterns, user flows
+
+### 2. Document Discovery
+
+Search for required documents (a sharded document is a folder with `index.md`; prefer whole document over sharded):
+
+**PRD:** `{planning_artifacts}/*prd*.md` or `{planning_artifacts}/*prd*/index.md`
+**Architecture:** `{planning_artifacts}/*architecture*.md` or `{planning_artifacts}/*architecture*/index.md`
+**UX Design:** `{planning_artifacts}/*ux*.md` or `{planning_artifacts}/*ux*/index.md`
+
+Ask the user if there are other documents to include or if anything found should be excluded. **Wait for user confirmation.** Once confirmed, create {outputFile} from {epicsTemplate} and list confirmed files in frontmatter `inputDocuments: []`.
+
+### 3. Extract Functional Requirements (FRs)
+
+Read the entire PRD and extract all FRs — numbered statements describing what the system must DO (user actions, system behaviors, business rules).
+
+Format: `FR1: [Clear, testable requirement]`
+
+### 4. Extract Non-Functional Requirements (NFRs)
+
+From the PRD, extract performance, security, usability, reliability, and compliance requirements.
+
+Format: `NFR1: [Quality/constraint requirement]`
+
+### 5. Extract Requirements from Architecture
+
+Review Architecture for technical requirements affecting epic/story creation:
+
+- **Starter Template** — If specified, note prominently (impacts Epic 1 Story 1)
+- Infrastructure, deployment, integration, migration, monitoring, security implementation requirements
+
+Format: `- [Technical requirement from Architecture]`
+
+### 6. Extract Requirements from UX (if exists)
+
+From UX document: responsive design, accessibility, browser/device compatibility, interaction patterns, animation requirements, error handling UX.
+
+Add to Additional Requirements list.
+
+### 7. Initialize Template
+
+Copy {epicsTemplate} to {outputFile}:
+
+1. Replace `{{project_name}}` with actual project name
+2. Replace `{{fr_list}}` with extracted FRs
+3. Replace `{{nfr_list}}` with extracted NFRs
+4. Replace `{{additional_requirements}}` with extracted additional requirements
+5. Leave `{{requirements_coverage_map}}` and `{{epics_list}}` as placeholders
+
+### 8. Present Extracted Requirements and Get Confirmation
+
+Display to user:
+
+- FR count with first few examples — ask if any are missing/incorrect
+- Key NFRs — ask if any constraints were missed
+- Summary of Architecture/UX requirements — verify completeness
+
+Ask: **"Do these extracted requirements accurately represent what needs to be built? Any additions or corrections?"**
+
+Update requirements based on user feedback until confirmed.
+
+### 9. Save and Present Menu
+
+After confirmation, update {outputFile} with the complete FR, NFR, and additional requirements lists.
+
+Display: **`Confirm the Requirements are complete and correct to [C] continue:`**
+
+**Menu handling:**
+
+- **C:** Save all to {outputFile}, update frontmatter, then read fully and follow: {nextStepFile}
+- **Any other input:** Respond to the question/comment, then redisplay this menu
+
+Always halt and wait for user input at this menu.
+
+---
+
+## SUCCESS METRICS
+
+- All required documents found and validated
+- All FRs and NFRs extracted and correctly formatted
+- Additional requirements from Architecture/UX identified
+- Template initialized with requirements
+- User confirms requirements are complete and accurate

package/src/bmm/workflows/3-solutioning/create-epics-and-stories/steps/step-02-design-epics.md

@@ -0,0 +1,124 @@
+---
+name: 'step-02-design-epics'
+description: 'Design and approve the epics_list that will organize all requirements into user-value-focused epics'
+
+# Path Definitions
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/create-epics-and-stories'
+
+# File References
+thisStepFile: './step-02-design-epics.md'
+nextStepFile: './step-03-create-stories.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{planning_artifacts}/epics.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_bmad/core/workflows/party-mode/workflow.md'
+
+# Template References
+epicsTemplate: '{workflow_path}/templates/epics-template.md'
+---
+
+# Step 2: Design Epic List
+
+**Goal:** Design and get explicit approval for the `epics_list` that organizes all requirements into user-value-focused epics.
+
+**Rules:** Read this entire file before acting. Focus only on the epics_list — do not create individual stories. Each epic must be standalone and enable future epics without requiring them.
+
+---
+
+## EPIC DESIGN PROCESS
+
+### 1. Review Extracted Requirements
+
+Load {outputFile} and review FRs, NFRs, and additional requirements from Step 1.
+
+### 2. Epic Design Principles
+
+**Organize by USER VALUE, not technical layers:**
+
+✅ CORRECT — each epic delivers standalone user value:
+- Epic 1: User Authentication & Profiles (complete auth system)
+- Epic 2: Content Creation (uses auth, creates content)
+- Epic 3: Social Interaction (uses auth + content)
+
+❌ WRONG — technical milestones with no direct user value:
+- Epic 1: Database Setup
+- Epic 2: API Development
+- Epic 3: Frontend Components
+
+**Dependency rule:** Epic N+1 can build on previous epics but must deliver complete functionality for its own domain. Epic 2 must not require Epic 3 to function.
+
+### 3. Design Epic Structure
+
+**A. Identify user value themes** — look for natural FR groupings, user journeys, user types and goals.
+
+**B. For each proposed epic, define:**
+1. Epic title (user-centric)
+2. User outcome (what users can accomplish after this epic)
+3. FR coverage (which FR numbers it addresses)
+4. Any technical/UX notes
+
+**C. Format the epics_list:**
+
+```
+## Epic List
+
+### Epic 1: [Epic Title]
+[Epic goal — what users can accomplish]
+**FRs covered:** FR1, FR2, FR3
+
+### Epic 2: [Epic Title]
+[Epic goal]
+**FRs covered:** FR4, FR5, FR6
+```
+
+### 4. Create Requirements Coverage Map
+
+```
+### FR Coverage Map
+
+FR1: Epic 1 - [Brief description]
+FR2: Epic 1 - [Brief description]
+FR3: Epic 2 - [Brief description]
+```
+
+### 5. Collaborative Refinement
+
+Ask:
+- "Does this epic structure align with your product vision?"
+- "Are all user outcomes properly captured?"
+- "Should we adjust any epic groupings?"
+
+### 6. Get Final Approval
+
+**Must get explicit user approval:** "Do you approve this epic structure for proceeding to story creation?"
+
+If changes are requested: adjust, update epics_list, re-present for approval. Repeat until approved.
+
+### 7. Save and Present Menu
+
+After approval, update {outputFile}:
+1. Replace `{{epics_list}}` with the approved epic list
+2. Replace `{{requirements_coverage_map}}` with the coverage map
+
+Display: **`Select an Option: [A] Advanced Elicitation [P] Party Mode [AR] Adversarial Review [C] Continue`**
+
+**Menu handling:**
+- **A:** Read fully and follow: {advancedElicitationTask}
+- **P:** Read fully and follow: {partyModeWorkflow}
+- **AR:** Execute `{project-root}/_bmad/core/tasks/review-adversarial-general.xml` — display findings, then redisplay menu
+- **C:** Save approved epics_list to {outputFile}, update frontmatter, then read fully and follow: {nextStepFile}
+- **Any other input:** Respond, then redisplay menu
+
+Always halt and wait for user input at this menu.
+
+---
+
+## SUCCESS METRICS
+
+- Epics organized around user value (not technical layers)
+- All FRs mapped to specific epics
+- Requirements coverage map completed
+- User gives explicit approval for epic structure
+- Document updated with approved epics