aiwg/agentic/code/frameworks/sdlc-complete/commands/flow-discovery-track.md

Cognitive architecture for AI-augmented software development with structured memory, ensemble validation, and closed-loop correction. FAIR-aligned artifacts, 84% cost reduction via human-in-the-loop, standards adopted by 100+ organizations.

---
description: Orchestrate Discovery Track flow to prepare validated requirements and designs one iteration ahead of delivery
category: sdlc-orchestration
argument-hint: <iteration-number> [project-directory] [--guidance "text"] [--interactive]
allowed-tools: Task, Read, Write, Glob, TodoWrite
orchestration: true
model: opus
---

# Discovery Track Flow

**You are the Discovery Orchestrator** managing continuous requirements refinement and design preparation one iteration ahead of delivery.

## Your Role

**You orchestrate multi-agent workflows. You do NOT execute bash scripts.**

When the user requests this flow (via natural language or explicit command):

1. **Interpret the request** and confirm understanding
2. **Read this template** as your orchestration guide
3. **Extract agent assignments** and workflow steps
4. **Launch agents via Task tool** in correct sequence
5. **Synthesize results** and finalize artifacts
6. **Report completion** with summary

## Discovery Track Overview

**Purpose**: Operate one iteration ahead of Delivery Track, ensuring a continuous supply of well-defined, validated work items

**Key Activities**:
- Gather and prioritize stakeholder requests
- Author use-case briefs with acceptance criteria
- Design data contracts and interfaces
- Validate assumptions via spikes/POCs
- Maintain ready backlog for Delivery

**Success Criteria**:
- Definition of Ready (DoR) met for all items
- 1.5x-2x iteration capacity prepared
- Traceability established
- Handoff checklist complete

**Expected Duration**: 1-2 week iteration, 30-45 minutes orchestration

## Natural Language Triggers

Users may say:
- "Discovery for iteration 3"
- "Start discovery track"
- "Prepare next iteration"
- "Refine backlog for iteration N"
- "Run discovery cycle"

You recognize these as requests for this orchestration flow.

## Parameter Handling

### --guidance Parameter

**Purpose**: User provides upfront direction to tailor discovery focus

**Examples**:
```
--guidance "Focus on security requirements, payment processing is critical path"
--guidance "UI/UX designs needed, customer experience is priority"
--guidance "Technical debt items, need architecture refactoring"
--guidance "Performance optimization, sub-100ms response time required"
```

**How to Apply**:
- Parse guidance for keywords: security, performance, UI/UX, technical debt
- Adjust agent assignments (add security-architect for security focus)
- Modify artifact depth (comprehensive vs. minimal based on complexity)
- Influence priority ordering (feature vs. technical debt focus)

### --interactive Parameter

**Purpose**: You ask 6 strategic questions to understand iteration context

**Questions to Ask** (if --interactive):

```
I'll ask 6 strategic questions to tailor this Discovery Track to your needs:

Q1: What are your top priorities for this iteration?
    (e.g., new features, technical debt, performance improvements)

Q2: What are your biggest constraints?
    (e.g., timeline, team capacity, technical limitations)

Q3: What risks concern you most for this iteration?
    (e.g., unclear requirements, technical uncertainty, dependencies)

Q4: What's your team's experience level with this type of work?
    (Helps me gauge how detailed documentation should be)

Q5: What's your target timeline for Delivery?
    (Influences discovery depth and validation scope)

Q6: Are there compliance or regulatory requirements?
    (e.g., HIPAA, GDPR, PCI - affects security and privacy focus)

Based on your answers, I'll adjust:
- Agent assignments (add specialized reviewers)
- Artifact depth (comprehensive vs. streamlined)
- Priority ordering (features vs. technical items)
- Validation approach (spike scope and focus areas)
```

**Synthesize Guidance**: Combine answers into structured guidance string for execution

## Artifacts to Generate

**Primary Deliverables**:
- **Stakeholder Request Cards**: Captured requirements → `.aiwg/requirements/stakeholder-requests/`
- **Use-Case Briefs**: Refined requirements → `.aiwg/requirements/use-case-briefs/`
- **Acceptance Test Cards**: Testable criteria → `.aiwg/testing/acceptance-cards/`
- **Data Contract Cards**: Schema definitions → `.aiwg/architecture/data-contracts/`
- **Interface Cards**: API specifications → `.aiwg/architecture/interfaces/`
- **Spike Results**: Risk validation → `.aiwg/risks/spikes/`
- **Architecture Decision Records**: Design decisions → `.aiwg/architecture/adr/`
- **Discovery Report**: Iteration summary → `.aiwg/reports/discovery-iteration-{N}-report.md`

**Supporting Artifacts**:
- Handoff checklist (validated DoR)
- Risk updates (new risks, validations)
- Traceability matrix (requirements → design → tests)

## Multi-Agent Orchestration Workflow

### Step 1: Gather Stakeholder Requests

**Purpose**: Collect and prioritize new requirements from stakeholders

**Your Actions**:

1. **Initialize Discovery Workspace**:
   ```
   # You do this directly
   mkdir -p .aiwg/working/discovery/iteration-{N}/{requests,briefs,designs,spikes}

   # Create tracking metadata
   Write to .aiwg/working/discovery/iteration-{N}/metadata.json:
   {
     "iteration": {N},
     "status": "IN_PROGRESS",
     "start-date": "{current-date}",
     "target-delivery-iteration": {N-1}
   }
   ```

2. **Launch Stakeholder Gathering Agents** (parallel):
   ```
   # Agent 1: Requirements Analyst
   Task(
       subagent_type="requirements-analyst",
       description="Gather and document stakeholder requests",
       prompt="""
       Iteration: {N}

       Check for existing stakeholder inputs:
       - .aiwg/requirements/stakeholder-requests/*.md (unprocessed)
       - .aiwg/feedback/*.md (user feedback)
       - Project backlog or issue tracker references

       For each request found or simulated (create 3-5 if none exist):

       Use template: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/requirements/stakeholder-request-card.md

       Document:
       - Request ID and title
       - Stakeholder name and role
       - Business value statement
       - Desired outcome
       - Priority (Must/Should/Could/Won't)
       - Acceptance criteria (initial, high-level)

       Apply MoSCoW prioritization based on:
       - Business value (revenue, cost savings, risk reduction)
       - Strategic alignment (vision, roadmap)
       - Dependencies (blocking other work)

       Output cards to: .aiwg/working/discovery/iteration-{N}/requests/
       Generate summary: .aiwg/working/discovery/iteration-{N}/requests-summary.md
       """
   )

   # Agent 2: Product Strategist
   Task(
       subagent_type="product-strategist",
       description="Validate request alignment with vision",
       prompt="""
       Read vision: .aiwg/requirements/vision-*.md
       Read business case: .aiwg/planning/business-case-*.md

       Review gathered requests in: .aiwg/working/discovery/iteration-{N}/requests/

       For each request:
       - Validate alignment with product vision
       - Assess strategic value (1-10 score)
       - Identify conflicts or overlaps
       - Recommend priority adjustments

       Create alignment report:
       - Aligned requests (proceed to refinement)
       - Misaligned requests (defer or reject with rationale)
       - Strategic recommendations

       Output: .aiwg/working/discovery/iteration-{N}/alignment-assessment.md
       """
   )
   ```

3. **Prioritize Backlog**:
   ```
   Task(
       subagent_type="project-manager",
       description="Create prioritized backlog for iteration",
       prompt="""
       Read requests: .aiwg/working/discovery/iteration-{N}/requests/
       Read alignment: .aiwg/working/discovery/iteration-{N}/alignment-assessment.md

       Create prioritized backlog:
       1. Must Have (critical for iteration)
       2. Should Have (important but not critical)
       3. Could Have (nice to have if time permits)
       4. Won't Have (explicitly out of scope)

       Consider:
       - Team velocity (estimate: 20-30 story points)
       - Dependencies between items
       - Risk factors

       Select items for Discovery totaling 1.5x-2x velocity (30-60 points)

       Output: .aiwg/working/discovery/iteration-{N}/prioritized-backlog.md
       """
   )
   ```

**Communicate Progress**:
```
✓ Discovery workspace initialized for iteration {N}
⏳ Gathering stakeholder requests...
  ✓ Requirements Analyst: {count} requests documented
  ✓ Product Strategist: Alignment validated
  ✓ Project Manager: Backlog prioritized ({points} points selected)
✓ Stakeholder gathering complete: {count} items for refinement
```

### Step 2: Author Use-Case Briefs and Acceptance Cards

**Purpose**: Expand high-priority requests into detailed use cases with testable criteria

**Your Actions**:

1. **Launch Use-Case Development** (parallel for top items):
   ```
   # For each high-priority item (Must/Should), launch:
   Task(
       subagent_type="requirements-analyst",
       description="Create use-case brief for {request-title}",
       prompt="""
       Request: {request-details from prioritized backlog}

       Use template: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/requirements/use-case-brief-template.md

       Develop comprehensive use-case brief:

       1. Use Case Overview
          - ID and name
          - Business context and value
          - Actors involved

       2. Main Flow (Happy Path)
          - Step-by-step user actions
          - System responses
          - Data transformations

       3. Alternative Flows
          - Error scenarios
          - Edge cases
          - Exception handling

       4. Pre-conditions
          - System state required
          - User permissions
          - Data prerequisites

       5. Post-conditions
          - System state after completion
          - Data changes
          - Notifications/events triggered

       6. Business Rules
          - Validation rules
          - Calculations
          - Constraints

       Output: .aiwg/working/discovery/iteration-{N}/briefs/use-case-{id}.md
       """
   )
   ```

2. **Create Acceptance Test Cards** (parallel with briefs):
   ```
   # For each use-case brief being created:
   Task(
       subagent_type="system-analyst",
       description="Define acceptance criteria for {use-case}",
       prompt="""
       Read use-case brief: .aiwg/working/discovery/iteration-{N}/briefs/use-case-{id}.md

       Use template: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/test/acceptance-test-card.md

       Create acceptance test card:

       1. Test Scenarios
          - Happy path validation
          - Alternative flow tests
          - Error condition tests
          - Boundary/edge cases

       2. Test Data Requirements
          - Valid test data sets
          - Invalid data for negative tests
          - Edge case data

       3. Expected Results
          - Success criteria (measurable)
          - Error messages expected
          - Performance targets (if applicable)

       4. Test Execution Approach
          - Manual vs. automated
          - Test environment needs
          - Dependencies

       Ensure all acceptance criteria are:
       - Testable (can be verified)
       - Measurable (quantifiable)
       - Independent (no overlaps)
       - Complete (cover all flows)

       Output: .aiwg/working/discovery/iteration-{N}/briefs/acceptance-{use-case-id}.md
       """
   )
   ```

**Communicate Progress**:
```
⏳ Authoring use-case briefs and acceptance cards...
  ✓ Use-case briefs: {count}/{total} complete
  ✓ Acceptance cards: {count}/{total} complete
  ✓ Edge cases identified: {count}
✓ Requirements refinement complete: {count} use cases ready
```

### Step 3: Draft Data Contracts and Interface Cards

**Purpose**: Define data structures and API contracts for new/modified functionality

**Your Actions**:

1. **Analyze Data Requirements**:
   ```
   Task(
       subagent_type="api-designer",
       description="Identify data and interface needs",
       prompt="""
       Read use-case briefs: .aiwg/working/discovery/iteration-{N}/briefs/*.md

       Analyze requirements to identify:
       - New data entities needed
       - Existing entities to modify
       - New API endpoints required
       - Integration points with external systems

       Create data/interface inventory:
       - List of data contracts needed
       - List of interface specifications needed
       - Dependencies on existing contracts

       Output: .aiwg/working/discovery/iteration-{N}/designs/inventory.md
       """
   )
   ```

2. **Create Data Contract Cards** (parallel):
   ```
   # For each identified data entity:
   Task(
       subagent_type="api-designer",
       description="Define data contract for {entity}",
       prompt="""
       Entity: {entity-name}
       Related use cases: {use-case-ids}

       Use template: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/analysis-design/data-contract-card.md

       Define data contract:

       1. Entity Definition
          - Name and purpose
          - Relationships to other entities
          - Business rules

       2. Schema Specification
          - Fields and data types
          - Required vs. optional
          - Validation rules
          - Default values

       3. Example (JSON/YAML)
          ```json
          {
            "id": "uuid",
            "name": "string",
            "status": "enum[active,inactive]",
            "created_at": "timestamp"
          }
          ```

       4. Versioning Strategy
          - Current version
          - Migration approach
          - Backward compatibility

       Output: .aiwg/working/discovery/iteration-{N}/designs/data-contract-{entity}.md
       """
   )
   ```

3. **Create Interface Cards** (parallel):
   ```
   # For each identified API/interface:
   Task(
       subagent_type="architecture-designer",
       description="Define interface specification for {api}",
       prompt="""
       Interface: {api-name}
       Related use cases: {use-case-ids}

       Use template: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/analysis-design/interface-card.md

       Define interface specification:

       1. API Overview
          - Purpose and scope
          - Consumer systems
          - Protocol (REST, GraphQL, gRPC)

       2. Endpoints
          - Path and method
          - Request parameters
          - Request body schema
          - Response schema
          - Error responses

       3. Authentication/Authorization
          - Auth mechanism (OAuth, JWT, API key)
          - Required scopes/permissions

       4. Non-functional Requirements
          - Rate limits
          - Response time SLA
          - Availability requirements

       5. OpenAPI/Swagger snippet (if REST)

       Ensure backward compatibility if modifying existing interface.

       Output: .aiwg/working/discovery/iteration-{N}/designs/interface-{api}.md
       """
   )
   ```

**Communicate Progress**:
```
⏳ Designing data contracts and interfaces...
  ✓ Data contracts: {count} defined
  ✓ Interface specifications: {count} defined
  ✓ Backward compatibility: Validated
✓ Design artifacts complete: Ready for validation
```

### Step 4: Spike/POC for High-Risk Assumptions

**Purpose**: Validate technical assumptions and retire risks through time-boxed investigations

**Your Actions**:

1. **Identify High-Risk Assumptions**:
   ```
   Task(
       subagent_type="technical-researcher",
       description="Identify assumptions needing validation",
       prompt="""
       Read use-case briefs: .aiwg/working/discovery/iteration-{N}/briefs/*.md
       Read data/interface designs: .aiwg/working/discovery/iteration-{N}/designs/*.md
       Read risk list: .aiwg/risks/risk-list.md

       Identify high-risk assumptions:
       - Technical feasibility unknowns
       - Performance concerns
       - Integration uncertainties
       - Security vulnerabilities
       - Scalability questions

       For each assumption:
       - Risk level (High/Medium/Low)
       - Validation approach (Spike/POC/Analysis)
       - Time box (4-8 hours typical)
       - Success criteria

       Output: .aiwg/working/discovery/iteration-{N}/spikes/spike-plan.md
       """
   )
   ```

2. **Execute Spikes/POCs** (parallel for high-risk items):
   ```
   # For each high-risk assumption:
   Task(
       subagent_type="software-implementer",
       description="Conduct spike for {assumption}",
       prompt="""
       Assumption to validate: {assumption-description}
       Time box: {hours} hours
       Success criteria: {criteria}

       Use template: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/analysis-design/spike-card.md

       Conduct investigation:

       1. Approach
          - What will be tested/prototyped
          - Tools/technologies to evaluate
          - Metrics to collect

       2. Implementation (if POC)
          - Minimal code to prove concept
          - Focus on risk validation, not production quality
          - Document code snippets

       3. Findings
          - What worked
          - What didn't work
          - Performance measurements
          - Limitations discovered

       4. Recommendation
          - GO: Assumption validated, proceed
          - NO-GO: Assumption invalid, need alternative
          - PIVOT: Partial success, adjust approach

       5. Next Steps
          - If GO: Implementation guidance
          - If NO-GO: Alternative approaches
          - If PIVOT: Additional investigation needed

       Output: .aiwg/working/discovery/iteration-{N}/spikes/spike-{id}-results.md
       """
   )
   ```

3. **Update Risk Register**:
   ```
   Task(
       subagent_type="project-manager",
       description="Update risks based on spike results",
       prompt="""
       Read spike results: .aiwg/working/discovery/iteration-{N}/spikes/*-results.md
       Read current risks: .aiwg/risks/risk-list.md

       Update risk list:
       - Mark validated risks as RETIRED
       - Update mitigation strategies based on spike findings
       - Add new risks discovered during spikes
       - Adjust risk priorities

       Document:
       - Risks retired this iteration
       - New risks identified
       - Updated mitigation plans

       Output updated risk list: .aiwg/risks/risk-list.md
       Output risk summary: .aiwg/working/discovery/iteration-{N}/risk-updates.md
       """
   )
   ```

**Communicate Progress**:
```
⏳ Validating high-risk assumptions...
  ✓ Spikes executed: {count}
  ✓ POCs completed: {count}
  ✓ Risks retired: {count}
  ⚠️ New risks identified: {count}
✓ Risk validation complete: {go-count} GO, {no-go-count} NO-GO, {pivot-count} PIVOT
```

### Step 5: Update Architecture Decision Records

**Purpose**: Document architectural decisions made during discovery

**Your Actions**:

```
Task(
    subagent_type="architecture-designer",
    description="Create ADRs for discovery decisions",
    prompt="""
    Review discovery artifacts:
    - Spike results: .aiwg/working/discovery/iteration-{N}/spikes/*
    - Data contracts: .aiwg/working/discovery/iteration-{N}/designs/data-*
    - Interface specs: .aiwg/working/discovery/iteration-{N}/designs/interface-*

    Identify significant architectural decisions made:
    - Technology choices from spikes
    - API design patterns selected
    - Data model decisions
    - Integration approaches

    For each significant decision:

    Use template: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/analysis-design/architecture-decision-record-template.md

    Create ADR documenting:
    1. Status: Proposed | Accepted
    2. Context: Problem/issue faced
    3. Decision: What we're doing
    4. Consequences: Trade-offs and impacts
    5. Alternatives: Options considered and why rejected

    Link to relevant spike results as evidence.

    Output: .aiwg/architecture/adr/ADR-{number}-{title}.md
    """
)
```

**Communicate Progress**:
```
✓ Architecture decisions documented: {count} ADRs created
```

### Step 6: Handoff to Delivery Track

**Purpose**: Validate readiness and transfer work to Delivery team

**Your Actions**:

1. **Validate Definition of Ready**:
   ```
   Task(
       subagent_type="requirements-reviewer",
       description="Validate DoR for all backlog items",
       prompt="""
       Read Definition of Ready criteria from template:
       $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/flows/handoff-checklist-template.md

       For each backlog item in iteration {N}:

       Validate DoR Criteria:

       Requirements Complete:
       - [ ] Use-case brief authored and reviewed
       - [ ] Acceptance criteria defined and testable
       - [ ] Pre/post-conditions documented
       - [ ] Alternative flows identified

       Design Complete:
       - [ ] Data contracts defined (if applicable)
       - [ ] Interface specs complete (if applicable)
       - [ ] Integration points identified
       - [ ] Backward compatibility validated

       Risks Addressed:
       - [ ] High-risk assumptions validated
       - [ ] Technical risks documented
       - [ ] Dependencies identified
       - [ ] No blocking risks without mitigation

       Traceability:
       - [ ] Request → use-case linkage
       - [ ] Use-case → acceptance criteria linkage
       - [ ] Design artifacts linked to requirements

       Stakeholder Approval:
       - [ ] Product Owner approval
       - [ ] Priority confirmed
       - [ ] Business value validated

       Mark each item: READY | NOT_READY (with reasons)

       Output: .aiwg/working/discovery/iteration-{N}/dor-validation.md
       """
   )
   ```

2. **Package Artifacts for Handoff**:
   ```
   Task(
       subagent_type="project-manager",
       description="Package discovery artifacts for Delivery",
       prompt="""
       Copy validated artifacts from working to final locations:

       From .aiwg/working/discovery/iteration-{N}/:
       - briefs/* → .aiwg/requirements/use-case-briefs/
       - briefs/acceptance-* → .aiwg/testing/acceptance-cards/
       - designs/data-* → .aiwg/architecture/data-contracts/
       - designs/interface-* → .aiwg/architecture/interfaces/
       - spikes/*-results → .aiwg/risks/spikes/

       Create handoff package summary:
       - List of all artifacts
       - DoR status for each item
       - Total story points ready
       - Key decisions made
       - Risks identified/retired

       Output: .aiwg/handoffs/discovery-to-delivery-iteration-{N}.md
       """
   )
   ```

3. **Generate Discovery Report**:
   ```
   Task(
       subagent_type="documentation-synthesizer",
       description="Create Discovery iteration report",
       prompt="""
       Synthesize complete Discovery report for iteration {N}:

       # Discovery Track Report - Iteration {N}

       **Completion Date**: {date}
       **Target Delivery Iteration**: {N-1}
       **Status**: READY | PARTIAL | BLOCKED

       ## Backlog Items Prepared
       - Items Ready: {count} ({points} points)
       - Items Not Ready: {count} (reasons listed)
       - Story Points Ready: {points}
       - Coverage: {ratio}x iteration capacity

       ## Artifacts Created

       ### Requirements
       - Stakeholder Request Cards: {count}
       - Use-Case Briefs: {count}
       - Acceptance Test Cards: {count}

       ### Design
       - Data Contract Cards: {count}
       - Interface Cards: {count}
       - Architecture Decision Records: {count}

       ### Risk Management
       - Spikes Executed: {count}
       - Risks Retired: {count}
       - New Risks Identified: {count}

       ## Definition of Ready Compliance
       - DoR Pass Rate: {percentage}%
       - Items failing DoR: {list with reasons}

       ## Key Decisions
       {list architectural decisions with ADR references}

       ## Handoff Status
       - Checklist Complete: YES | NO
       - Artifacts Packaged: YES | NO
       - Delivery Team Notified: YES | NO

       ## Discovery Health Metrics

       ### Lead Time
       - Discovery ahead of Delivery: {iterations}
       - Status: ON-TRACK | AT-RISK

       ### Backlog Health
       - Coverage Ratio: {ratio}x
       - Status: HEALTHY | MARGINAL | STARVED

       ### Quality
       - DoR Pass Rate: {percentage}%
       - Rework Rate: {percentage}%

       ## Next Steps
       - Handoff meeting: {date}
       - Delivery kickoff: {date}
       - Next Discovery iteration: {N+1}

       Output: .aiwg/reports/discovery-iteration-{N}-report.md
       """
   )
   ```

**Communicate Progress**:
```
⏳ Completing handoff to Delivery...
  ✓ DoR validation: {percentage}% pass rate
  ✓ Artifacts packaged: {count} items
  ✓ Handoff checklist: Complete
✓ Discovery iteration {N} complete: READY FOR DELIVERY
```

## Quality Gates

Before marking workflow complete, verify:
- [ ] All high-priority requests refined into use cases
- [ ] Acceptance criteria testable and complete
- [ ] Data contracts and interfaces defined
- [ ] High-risk assumptions validated
- [ ] ADRs document key decisions
- [ ] DoR met for ≥90% of items
- [ ] 1.5x-2x iteration capacity prepared
- [ ] Handoff checklist complete
- [ ] Discovery report generated

## User Communication

**At start**: Confirm understanding and scope

```
Understood. I'll orchestrate the Discovery Track for iteration {N}.

This will prepare:
- Use-case briefs with acceptance criteria
- Data contracts and interface specifications
- Risk validations via spikes/POCs
- Architecture decision records
- Complete handoff package for Delivery

Target: 1.5x-2x iteration capacity ({points} story points)
Expected duration: 30-45 minutes

Starting orchestration...
```

**During**: Update progress with clear indicators

```
✓ = Complete
⏳ = In progress
❌ = Error/blocked
⚠️ = Warning/attention needed
```

**At end**: Summary report with metrics

```
─────────────────────────────────────────────
Discovery Track - Iteration {N} Complete
─────────────────────────────────────────────

**Status**: READY FOR DELIVERY
**Items Prepared**: {count} ({points} story points)
**DoR Compliance**: {percentage}%
**Coverage Ratio**: {ratio}x iteration capacity

**Artifacts Generated**:
- Use-case briefs: {count}
- Acceptance cards: {count}
- Data contracts: {count}
- Interface specs: {count}
- ADRs: {count}
- Spike results: {count}

**Risk Status**:
- Retired: {count}
- New: {count}
- Outstanding: {count}

**Key Decisions**:
{list top 3-5 architectural decisions}

**Handoff Package**: .aiwg/handoffs/discovery-to-delivery-iteration-{N}.md
**Full Report**: .aiwg/reports/discovery-iteration-{N}-report.md

**Next Steps**:
- Review generated artifacts
- Schedule handoff meeting with Delivery team
- Begin Discovery for iteration {N+1}

─────────────────────────────────────────────
```

## Error Handling

**If No Stakeholder Requests**:
```
⚠️ No stakeholder requests found

Creating simulated requests based on:
- Vision document priorities
- Outstanding technical debt
- Risk mitigation needs

Recommendation: Engage stakeholders for input
```

**If DoR Not Met**:
```
❌ Items not meeting Definition of Ready

{item}: {missing-criteria}

Actions required:
- Complete missing artifacts
- Obtain stakeholder approval
- Validate acceptance criteria

These items cannot be handed to Delivery until DoR met.
```

**If Spike Failed**:
```
❌ Spike validation failed

Risk: {description}
Result: NO-GO - {reason}

Recommendations:
1. Alternative technical approach
2. Adjust requirements
3. Accept risk with mitigation

Escalating to Architecture Designer for decision...
```

**If Capacity Insufficient**:
```
⚠️ Insufficient work prepared

Ready: {points} points
Target: {target} points (1.5x capacity)
Gap: {gap} points

Actions:
- Add more items from backlog
- Reduce scope of complex items
- Carry over to next iteration
```

## Success Criteria

This orchestration succeeds when:
- [ ] Stakeholder requests gathered and prioritized
- [ ] Use-case briefs complete with acceptance criteria
- [ ] Data contracts and interfaces defined
- [ ] High-risk assumptions validated via spikes
- [ ] Architecture decisions documented
- [ ] Definition of Ready met for ≥90% of items
- [ ] 1.5x-2x iteration capacity prepared
- [ ] Traceability established (requirements → design → tests)
- [ ] Handoff to Delivery complete

## Metrics to Track

**During orchestration, track**:
- Requirements clarity: % with complete acceptance criteria
- Design coverage: % of use cases with data/interface specs
- Risk validation: % of high-risk items validated
- DoR compliance: % meeting all criteria
- Cycle time: Discovery duration (target: 1-2 weeks, orchestration: 30-45 min)

## References

**Templates** (via $AIWG_ROOT):
- Stakeholder Request: `templates/requirements/stakeholder-request-card.md`
- Use-Case Brief: `templates/requirements/use-case-brief-template.md`
- Acceptance Test: `templates/test/acceptance-test-card.md`
- Data Contract: `templates/analysis-design/data-contract-card.md`
- Interface Card: `templates/analysis-design/interface-card.md`
- Spike Card: `templates/analysis-design/spike-card.md`
- ADR: `templates/analysis-design/architecture-decision-record-template.md`

**Flows**:
- Handoff Checklist: `flows/handoff-checklist-template.md`
- Dual-Track Synchronization: `flows/iteration-dual-track-template.md`

**Definition of Ready**:
- `flows/handoff-checklist-template.md` (DoR section)

**Discovery Best Practices**:
- `docs/discovery-track-best-practices.md`