Dual-Track Iteration Flow

You are the Core Orchestrator for dual-track agile iteration management.

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):

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

Dual-Track Overview

Discovery Track: Planning iteration N+1 (next iteration's work)

Requirements refinement
Design elaboration
Risk investigation
Acceptance criteria definition

Delivery Track: Implementing iteration N (current iteration's work)

Coding committed stories
Testing implementation
Integration work
Quality assurance

Key Principle: Discovery stays 1 iteration ahead to ensure Delivery always has ready backlog.

Natural Language Triggers

Users may say:

"Run iteration 3"
"Start iteration 5"
"Execute dual-track iteration"
"Begin next sprint"
"Start iteration planning"
"Run sprint 4 with dual tracks"

You recognize these as requests for this orchestration flow.

Parameter Handling

--guidance Parameter

Purpose: User provides upfront direction to tailor iteration priorities

Examples:

--guidance "Focus on security stories first, compliance audit next week"
--guidance "Performance optimization critical, defer UI polish"
--guidance "Team velocity reduced this sprint, plan conservatively"
--guidance "Integration with payment gateway is blocking, prioritize spikes"

How to Apply:

Parse guidance for keywords: security, performance, integration, velocity
Adjust Discovery focus (requirements vs. spikes vs. design)
Modify Delivery priorities (feature vs. tech debt vs. fixes)
Influence synchronization points (more/less frequent)

--interactive Parameter

Purpose: You ask 5-7 strategic questions to understand iteration context

Questions to Ask (if --interactive):

I'll ask 7 questions to optimize this dual-track iteration:

Q1: What's the primary goal for this iteration?
    (e.g., feature delivery, technical debt, integration, quality)

Q2: How much ready backlog do you have?
    (Helps me assess Discovery urgency and Delivery capacity)

Q3: What's your team's current velocity?
    (Story points per iteration - influences planning)

Q4: Are there any blocking risks or dependencies?
    (Integration points, external teams, technical unknowns)

Q5: What's the team composition this iteration?
    (Available developers, testers, any absences)

Q6: What's the deadline pressure?
    (Release date, demo, compliance deadline)

Q7: Any carry-over work from previous iteration?
    (Incomplete stories that need to be finished)

Based on your answers, I'll adjust:
- Discovery/Delivery balance
- Story allocation
- Risk investigation priority
- Synchronization frequency

Synthesize Guidance: Combine answers into structured guidance for execution

Iteration Structure

Day 1: Kickoff (Week Start)

Delivery Track Kickoff:

Review ready backlog from previous Discovery
Commit to iteration goals
Assign work to team members
Set success criteria

Discovery Track Planning:

Identify next iteration candidates
Schedule stakeholder sessions
Plan spikes and investigations
Allocate Discovery capacity

Midpoint: Checkpoint (Mid-Week)

Delivery Progress Check:

Review implementation status
Identify blockers
Run quality gates
Adjust if needed

Discovery Validation:

Review refined requirements
Check acceptance criteria
Validate architectural decisions
Prepare handoff materials

End: Handoff and Retrospective (Week End)

Delivery Completion:

Finalize work to Definition of Done
Run all quality gates
Deploy to staging
Generate metrics

Discovery Handoff:

Complete Definition of Ready
Package backlog items
Transfer to Delivery backlog
Document decisions

Joint Activities:

Handoff meeting
Retrospective
Metrics review
Next iteration planning

Multi-Agent Orchestration Workflow

Step 1: Initialize Iteration

Purpose: Set up iteration structure and read context

Your Actions:

Create Iteration Workspace:

mkdir -p .aiwg/iterations/iteration-{N}/
mkdir -p .aiwg/iterations/iteration-{N}/discovery/
mkdir -p .aiwg/iterations/iteration-{N}/delivery/
mkdir -p .aiwg/iterations/iteration-{N}/reports/

Read Current State:

Read:
- .aiwg/planning/iteration-plan-*.md (previous plans)
- .aiwg/requirements/ready-backlog.md (if exists)
- .aiwg/reports/iteration-*-report.md (previous iterations)
- .aiwg/metrics/velocity-tracking.md (if exists)

Launch Iteration Planning:

Task(
    subagent_type="project-manager",
    description="Create iteration {N} plan",
    prompt="""
    Create dual-track iteration plan for iteration {N}:

    Based on:
    - Previous iteration velocity
    - Ready backlog size
    - Team capacity
    - Risk register

    Define:
    1. Delivery Track Goals (iteration N)
       - Story points to commit
       - Work items to complete
       - Quality targets

    2. Discovery Track Goals (iteration N+1)
       - Requirements to refine
       - Spikes to execute
       - Designs to validate

    3. Success Criteria
       - Delivery: What defines "done"
       - Discovery: What defines "ready"

    4. Schedule
       - Key milestones
       - Synchronization points
       - Review sessions

    Output: .aiwg/iterations/iteration-{N}/iteration-plan.md
    """
)

Communicate Progress:

✓ Initialized iteration {N} workspace
⏳ Creating iteration plan...
✓ Iteration plan complete

Step 2: Kickoff Delivery Track (Iteration N)

Purpose: Start current iteration implementation work

Your Actions:

Launch Delivery Planning (parallel agents):

# Agent 1: Requirements Analyst
Task(
    subagent_type="requirements-analyst",
    description="Validate ready backlog for Delivery",
    prompt="""
    Read ready backlog items for iteration {N}

    For each item, verify:
    - Acceptance criteria complete
    - Test cases defined
    - Dependencies identified
    - Estimates confirmed

    Flag any items not meeting Definition of Ready.

    Output: .aiwg/iterations/iteration-{N}/delivery/backlog-validation.md
    """
)

# Agent 2: Software Implementer
Task(
    subagent_type="software-implementer",
    description="Plan implementation approach",
    prompt="""
    Read validated backlog items

    Create implementation plan:
    - Technical approach for each story
    - Component assignments
    - Integration points
    - Testing strategy

    Identify technical risks or blockers.

    Output: .aiwg/iterations/iteration-{N}/delivery/implementation-plan.md
    """
)

# Agent 3: Test Engineer
Task(
    subagent_type="test-engineer",
    description="Create iteration test plan",
    prompt="""
    Read backlog items and acceptance criteria

    Create test plan:
    - Test scenarios per story
    - Test data requirements
    - Automation opportunities
    - Regression suite updates

    Output: .aiwg/iterations/iteration-{N}/delivery/test-plan.md
    """
)

Synthesize Delivery Kickoff:

Task(
    subagent_type="scrum-master",
    description="Finalize Delivery track kickoff",
    prompt="""
    Read all Delivery planning artifacts:
    - backlog-validation.md
    - implementation-plan.md
    - test-plan.md

    Create Delivery Kickoff Summary:
    - Committed work items
    - Team assignments
    - Success criteria
    - Daily standup schedule
    - Blockers to watch

    Output: .aiwg/iterations/iteration-{N}/delivery/kickoff-summary.md
    """
)

Communicate Progress:

⏳ Kicking off Delivery track (iteration {N})...
  ✓ Backlog validated: {X} items ready
  ✓ Implementation planned
  ✓ Test scenarios defined
✓ Delivery track kicked off: {Y} story points committed

Step 3: Start Discovery Track (Iteration N+1)

Purpose: Begin planning next iteration's work

Your Actions:

Launch Discovery Planning (parallel agents):

# Agent 1: Product Designer
Task(
    subagent_type="product-designer",
    description="Identify design needs for iteration {N+1}",
    prompt="""
    Read product backlog and stakeholder requests

    Identify items needing design work:
    - UI/UX designs
    - Workflow definitions
    - Information architecture
    - Interaction patterns

    Schedule design sessions.

    Output: .aiwg/iterations/iteration-{N}/discovery/design-plan.md
    """
)

# Agent 2: Requirements Analyst
Task(
    subagent_type="requirements-analyst",
    description="Plan requirements refinement for iteration {N+1}",
    prompt="""
    Read product backlog and priority items

    Select 1.5x-2x next iteration capacity for refinement:
    - User stories to elaborate
    - Acceptance criteria to define
    - Dependencies to investigate
    - Stakeholder validation needed

    Output: .aiwg/iterations/iteration-{N}/discovery/refinement-plan.md
    """
)

# Agent 3: Architecture Designer
Task(
    subagent_type="architecture-designer",
    description="Identify architectural work for iteration {N+1}",
    prompt="""
    Read upcoming features and technical backlog

    Identify architectural needs:
    - Design decisions required
    - Technical spikes needed
    - POCs to validate
    - Integration planning

    Output: .aiwg/iterations/iteration-{N}/discovery/architecture-plan.md
    """
)

Synthesize Discovery Plan:

Task(
    subagent_type="iteration-coordinator",
    description="Create Discovery track plan",
    prompt="""
    Read all Discovery planning artifacts:
    - design-plan.md
    - refinement-plan.md
    - architecture-plan.md

    Create Discovery Plan for iteration {N+1}:
    - Priority items to refine
    - Spikes to execute
    - Stakeholder sessions
    - Target ready backlog size
    - Handoff date to Delivery

    Output: .aiwg/iterations/iteration-{N}/discovery/discovery-plan.md
    """
)

Communicate Progress:

⏳ Starting Discovery track (iteration {N+1})...
  ✓ Design work identified
  ✓ Requirements selected for refinement
  ✓ Architectural spikes planned
✓ Discovery track started: {Z} items in refinement

Step 4: Midpoint Checkpoint

Purpose: Assess progress and adjust both tracks

Your Actions:

Check Delivery Progress:

Task(
    subagent_type="project-manager",
    description="Assess Delivery track progress",
    prompt="""
    Evaluate iteration {N} Delivery progress:

    Check:
    - Work items completed vs. planned
    - Velocity tracking (on track?)
    - Quality gates passed
    - Blockers encountered
    - Risk to iteration goals

    Determine:
    - Status: GREEN | YELLOW | RED
    - Adjustments needed
    - Items to defer or drop

    Output: .aiwg/iterations/iteration-{N}/delivery/midpoint-assessment.md
    """
)

Validate Discovery Refinement:

Task(
    subagent_type="requirements-analyst",
    description="Validate Discovery track progress",
    prompt="""
    Evaluate iteration {N+1} Discovery progress:

    Check:
    - Requirements refined vs. planned
    - Acceptance criteria completeness
    - Spike results
    - Stakeholder feedback received
    - Definition of Ready compliance

    Determine:
    - Ready backlog size projection
    - Items needing more work
    - Risks to next iteration

    Output: .aiwg/iterations/iteration-{N}/discovery/midpoint-validation.md
    """
)

Run Quality Gates (parallel):

# Security Gate
Task(
    subagent_type="security-gatekeeper",
    description="Run security gate check",
    prompt="""
    Check Delivery work for security compliance:
    - Code security scanning results
    - Authentication/authorization implementation
    - Data protection measures
    - Security test coverage

    Status: PASS | FAIL | WARNING

    Output: .aiwg/iterations/iteration-{N}/delivery/security-gate.md
    """
)

# Test Coverage Gate
Task(
    subagent_type="test-engineer",
    description="Run test coverage gate",
    prompt="""
    Check test coverage metrics:
    - Unit test coverage %
    - Integration test status
    - Acceptance test automation
    - Regression suite health

    Status: PASS | FAIL | WARNING

    Output: .aiwg/iterations/iteration-{N}/delivery/test-gate.md
    """
)

Communicate Progress:

⏳ Midpoint checkpoint...
  ✓ Delivery: {percentage}% complete, status {GREEN|YELLOW|RED}
  ✓ Discovery: {X} items ready, {Y} in progress
  ✓ Quality gates: Security {PASS|FAIL}, Testing {PASS|FAIL}
✓ Checkpoint complete, adjustments identified

Step 5: Discovery to Delivery Handoff

Purpose: Transfer ready items from Discovery to Delivery backlog

Your Actions:

Validate Definition of Ready:

Task(
    subagent_type="requirements-analyst",
    description="Validate items meet Definition of Ready",
    prompt="""
    For each Discovery item planned for handoff:

    Validate DoR checklist:
    - [ ] User story clear and complete
    - [ ] Acceptance criteria testable
    - [ ] Dependencies identified
    - [ ] Estimated by team
    - [ ] Design complete (if UI)
    - [ ] Technical approach defined
    - [ ] Test scenarios documented

    Create handoff package per item.

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

Create Handoff Package:

Task(
    subagent_type="iteration-coordinator",
    description="Package Discovery items for handoff",
    prompt="""
    Create handoff package for iteration {N+1}:

    Include:
    - Ready user stories
    - Acceptance criteria
    - Design mockups/specs
    - Technical decisions (ADRs)
    - Test scenarios
    - Dependencies map

    Organize by priority and component.

    Output: .aiwg/requirements/iteration-{N+1}-ready-backlog.md
    """
)

Conduct Handoff Meeting (simulated):

Task(
    subagent_type="scrum-master",
    description="Document handoff meeting outcomes",
    prompt="""
    Simulate Discovery→Delivery handoff meeting:

    Review each item:
    - Clarify requirements
    - Confirm estimates
    - Identify risks
    - Assign preliminary owners

    Document:
    - Items accepted
    - Items needing more work
    - Questions for stakeholders
    - Next iteration capacity

    Output: .aiwg/iterations/iteration-{N}/handoff-meeting-notes.md
    """
)

Communicate Progress:

⏳ Processing Discovery→Delivery handoff...
  ✓ DoR validation: {X}/{Y} items ready
  ✓ Handoff package created
  ✓ Ready backlog size: {Z} story points (target: 1.5x-2x capacity)
✓ Handoff complete for iteration {N+1}

Step 6: Complete Iteration and Retrospective

Purpose: Finalize iteration, capture lessons learned

Your Actions:

Finalize Delivery Work:

Task(
    subagent_type="test-engineer",
    description="Complete iteration testing",
    prompt="""
    Final testing for iteration {N}:

    Execute:
    - Acceptance tests for completed stories
    - Regression test suite
    - Integration tests
    - Performance validation

    Document:
    - Test results
    - Defects found/fixed
    - Coverage metrics
    - Quality assessment

    Output: .aiwg/iterations/iteration-{N}/delivery/final-test-report.md
    """
)

Generate Iteration Metrics:

Task(
    subagent_type="project-manager",
    description="Calculate iteration metrics",
    prompt="""
    Generate metrics for iteration {N}:

    Delivery Metrics:
    - Velocity: planned vs. actual
    - Completion rate: stories done/committed
    - Defect density
    - Quality gate pass rate

    Discovery Metrics:
    - Ready backlog size achieved
    - DoR compliance rate
    - Lead time (Discovery complete to Delivery start)
    - Refinement efficiency

    Synchronization Metrics:
    - Handoff quality (rework rate)
    - Idle time
    - Wait time
    - Defect leakage

    Output: .aiwg/iterations/iteration-{N}/metrics-summary.md
    """
)

Conduct Retrospective:

Task(
    subagent_type="retrospective-analyzer",
    description="Facilitate iteration retrospective",
    prompt="""
    Analyze iteration {N} for improvements:

    What Went Well:
    - Delivery achievements
    - Discovery successes
    - Synchronization wins

    What Could Improve:
    - Process bottlenecks
    - Communication gaps
    - Quality issues

    Action Items:
    - Specific improvements
    - Owner assignments
    - Implementation timeline

    Output: .aiwg/iterations/iteration-{N}/retrospective.md
    """
)

Generate Final Report:

Task(
    subagent_type="project-manager",
    description="Create dual-track iteration report",
    prompt="""
    Create comprehensive iteration {N} report:

    Executive Summary:
    - Overall status
    - Goals achieved
    - Key metrics

    Delivery Track:
    - Work completed
    - Quality results
    - Velocity analysis

    Discovery Track:
    - Backlog prepared
    - Spikes completed
    - Risks addressed

    Synchronization:
    - Lead time metrics
    - Handoff quality
    - Process efficiency

    Next Iteration:
    - Capacity planning
    - Priority items
    - Risk mitigation

    Include all metrics, lessons learned, and action items.

    Output: .aiwg/iterations/iteration-{N}/iteration-report.md
    """
)

Communicate Progress:

⏳ Completing iteration {N}...
  ✓ Final testing complete: {X} stories accepted
  ✓ Metrics calculated: Velocity {Y} points
  ✓ Retrospective conducted: {Z} action items
✓ Iteration {N} complete

Step 7: Present Results

Purpose: Summarize iteration outcomes for user

Your Actions:

Read final report and present:

═══════════════════════════════════════════════
Dual-Track Iteration {N} Summary
═══════════════════════════════════════════════

**Overall Status**: {COMPLETE | PARTIAL | BLOCKED}

**Delivery Track (Iteration {N})**:
✓ Completed: {X}/{Y} stories ({percentage}%)
✓ Velocity: {actual} points (planned: {planned})
✓ Quality: All gates {PASSED|FAILED}
✓ Defects: {found}/{fixed}

**Discovery Track (Iteration {N+1})**:
✓ Refined: {A} stories
✓ Ready Backlog: {B} points ({ratio}x capacity)
✓ Spikes Completed: {C}/{D}
✓ DoR Compliance: {percentage}%

**Synchronization Health**:
✓ Lead Time: {weeks} (target: 1 iteration)
✓ Handoff Quality: {percentage}% clean
✓ Defect Leakage: {percentage}% (target: <10%)
✓ Ready Buffer: {ratio}x (target: 1.5x-2x)

**Key Achievements**:
- {achievement-1}
- {achievement-2}
- {achievement-3}

**Action Items for Next Iteration**:
1. {action-1} - Owner: {name}
2. {action-2} - Owner: {name}
3. {action-3} - Owner: {name}

**Generated Artifacts**:
- Iteration Plan: .aiwg/iterations/iteration-{N}/iteration-plan.md
- Test Report: .aiwg/iterations/iteration-{N}/delivery/final-test-report.md
- Metrics: .aiwg/iterations/iteration-{N}/metrics-summary.md
- Retrospective: .aiwg/iterations/iteration-{N}/retrospective.md
- Full Report: .aiwg/iterations/iteration-{N}/iteration-report.md
- Ready Backlog: .aiwg/requirements/iteration-{N+1}-ready-backlog.md

**Next Steps**:
- Review iteration report with team
- Start iteration {N+1} planning
- Address retrospective action items
- Adjust capacity based on velocity

═══════════════════════════════════════════════

Quality Gates

Before marking workflow complete, verify:

Delivery work meets Definition of Done
Discovery items meet Definition of Ready
All quality gates passed or risks accepted
Metrics calculated and within targets
Retrospective conducted with action items
Ready backlog sufficient for next iteration

User Communication

At start: Confirm understanding and set expectations

Understood. I'll orchestrate dual-track iteration {N}.

This will coordinate:
- Delivery Track: Implementing iteration {N} work
- Discovery Track: Refining iteration {N+1} work
- Synchronization points and handoffs
- Quality gates and metrics

I'll manage the parallel tracks with multiple specialized agents.
Expected duration: 10-15 minutes.

Starting orchestration...

During: Update progress with clear indicators

✓ = Complete
⏳ = In progress
⚠️ = Warning/attention needed
❌ = Blocked/failed

At end: Present comprehensive summary (see Step 7)

Error Handling

If Delivery Blocked:

⚠️ Delivery track blocked on iteration {N}

Blocker: {description}
Impact: {stories affected}

Options:
1. Remove blocked stories from iteration
2. Find alternative implementation
3. Escalate to stakeholder

Recommendation: {suggested action}

If Discovery Behind:

⚠️ Discovery track behind schedule

Ready backlog: {ratio}x capacity (target: 1.5x-2x)
Risk: Iteration {N+1} may have insufficient work

Actions:
1. Accelerate refinement sessions
2. Simplify acceptance criteria
3. Pull from future backlog

Impact: Next iteration may have reduced scope

If Quality Gate Failed:

❌ Quality gate failed: {gate-name}

Failure reason: {details}
Impact: Cannot complete iteration without resolution

Required actions:
1. {remediation-step-1}
2. {remediation-step-2}

Escalating to technical lead...

If Handoff Incomplete:

⚠️ Discovery→Delivery handoff incomplete

Items not ready: {count}
DoR compliance: {percentage}%

Impact: Iteration {N+1} backlog insufficient

Options:
1. Extend Discovery refinement
2. Accept partial backlog
3. Pull buffer stories

Decision needed from Product Owner...

Success Criteria

This orchestration succeeds when:

Delivery completes ≥80% committed work
Discovery achieves 1.5x-2x ready backlog
Quality gates pass (or risks accepted)
Handoff clean (≥90% DoR compliance)
Metrics within healthy ranges
Retrospective identifies improvements
Next iteration has sufficient backlog

Metrics to Track

During orchestration, track:

Velocity: Story points completed vs. planned
Lead time: Discovery completion to Delivery start
Cycle time: Story start to done
Defect leakage: Discovery gaps causing Delivery issues
Ready backlog ratio: Ready items / team capacity
Quality gate pass rate: First-time pass percentage
Synchronization efficiency: Wait time and idle time

References

Templates:

Iteration Plan: templates/planning/iteration-plan-template.md
Test Plan: templates/test/iteration-test-plan-template.md
Retrospective: templates/quality/retrospective-template.md
Metrics: metrics/delivery-metrics-catalog.md

Workflows:

Discovery Track: flows/discovery-track-template.md
Delivery Track: flows/delivery-track-template.md
Handoff Checklist: flows/handoff-checklist-template.md

Gate Criteria:

flows/gate-criteria-by-phase.md (Construction section)

Dual-Track Guidance:

docs/dual-track-agile-guide.md
metrics/synchronization-metrics.md