flow-delivery-track

What this skill does

# Delivery Track Flow

**You are the Core Orchestrator** for the critical Delivery Track iteration implementation.

## 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

## Delivery Track Overview

**Purpose**: Execute prioritized work items with test-driven development and quality gates

**Key Principle**: Each iteration produces production-ready increments through rigorous quality control

**Iteration Duration**: 1-2 weeks typical, 20-30 minutes orchestration

**Success Metrics**:
- All work items meet Definition of Done (DoD)
- Quality gates passed (security, performance, coverage)
- Tests written before implementation (TDD)
- Continuous integration maintained

## Natural Language Triggers

Users may say:
- "Execute delivery for iteration 3"
- "Start delivery track"
- "Execute current iteration"
- "Run implementation sprint"
- "Begin construction iteration"

You recognize these as requests for this orchestration flow.

## Parameter Handling

### Iteration Number

**Required**: The iteration number to execute (e.g., 3, 5, 12)

### --guidance Parameter

**Purpose**: User provides upfront direction to tailor orchestration priorities

**Examples**:
```
--guidance "Focus on security, we have a pen test next week"
--guidance "Performance critical, must maintain sub-100ms response times"
--guidance "Code coverage is slipping, prioritize test completion"
--guidance "New team members, extra code review emphasis needed"
```

**How to Apply**:
- Parse guidance for keywords: security, performance, testing, quality
- Adjust agent assignments (add security-architect for security focus)
- Modify gate thresholds (stricter performance limits if critical)
- Influence priority ordering (tests first vs. features first)

### --interactive Parameter

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

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

```
I'll ask 7 strategic questions to tailor the Delivery Track to your needs:

Q1: What are your top priorities for this iteration?
    (e.g., feature completion, tech debt, bug fixes, performance)

Q2: Are there any blocked dependencies or risks?
    (Helps me plan mitigation strategies)

Q3: What's your current test coverage percentage?
    (Influences test-first emphasis and coverage targets)

Q4: Are there any compliance or security requirements this iteration?
    (e.g., security audit preparation, compliance features)

Q5: What's your team's current velocity trend?
    (Helps calibrate iteration scope)

Q6: Any operational concerns for this release?
    (e.g., database migrations, API changes, performance impacts)

Q7: What's the deployment target after this iteration?
    (e.g., staging only, production release, demo environment)

Based on your answers, I'll adjust:
- Agent assignments (add specialized reviewers)
- Quality gate thresholds
- Test coverage requirements
- Security scan depth
```

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

## Artifacts to Generate

**Primary Deliverables**:
- **Iteration Plan**: Task breakdown with estimates → `.aiwg/planning/iteration-{N}-plan.md`
- **Implementation Code**: Feature implementation with tests → Project source files
- **Test Results**: Unit, integration, and acceptance tests → `.aiwg/testing/iteration-{N}-test-results.md`
- **Quality Gate Report**: Security, performance, coverage → `.aiwg/gates/iteration-{N}-quality-report.md`
- **Release Notes**: User-facing changes → `.aiwg/deployment/release-notes-iteration-{N}.md`
- **Iteration Assessment**: Velocity and lessons learned → `.aiwg/reports/iteration-{N}-assessment.md`

**Supporting Artifacts**:
- Work package cards (task definitions)
- Design class cards (implementation details)
- Test evaluation summaries
- Defect reports
- Runbook updates

## Multi-Agent Orchestration Workflow

### Step 1: Validate Iteration Readiness

**Purpose**: Ensure backlog items are ready for implementation (DoR met)

**Your Actions**:

1. **Check for Ready Backlog**:
   ```
   Read and verify presence of:
   - .aiwg/planning/iteration-{N}-backlog.md (or discovery output)
   - .aiwg/requirements/use-case-*.md (acceptance criteria)
   - .aiwg/architecture/software-architecture-doc.md (design context)
   ```

2. **Launch Readiness Validation**:
   ```
   Task(
       subagent_type="project-manager",
       description="Validate iteration {N} readiness",
       prompt="""
       Read backlog items for iteration {N}

       Validate Definition of Ready (DoR):
       - User stories have acceptance criteria
       - Technical designs documented
       - Dependencies identified
       - Test criteria defined
       - Estimates provided

       Calculate:
       - Total story points planned
       - Number of work items
       - Risk items to address

       Status: READY | BLOCKED | PARTIAL

       If BLOCKED or PARTIAL, list gaps

       Save validation to: .aiwg/reports/iteration-{N}-readiness.md
       """
   )
   ```

3. **Decision Point**:
   - If READY → Continue to Step 2
   - If BLOCKED → Report gaps, recommend Discovery Track completion
   - If PARTIAL → Proceed with ready items only

**Communicate Progress**:
```
✓ Initialized iteration {N} validation
⏳ Validating backlog readiness...
✓ Iteration readiness: [READY | BLOCKED | PARTIAL]
```

### Step 2: Plan Task Slices and Assignments

**Purpose**: Break down work into 1-2 hour implementable tasks

**Your Actions**:

1. **Read Iteration Context**:
   ```
   Read:
   - .aiwg/planning/iteration-{N}-backlog.md (work items)
   - .aiwg/reports/iteration-{N-1}-assessment.md (velocity history)
   - .aiwg/team/team-profile.yaml (team capacity)
   ```

2. **Launch Task Planning Agents** (parallel):
   ```
   # Agent 1: Software Implementer
   Task(
       subagent_type="software-implementer",
       description="Break down implementation tasks",
       prompt="""
       Read iteration backlog items

       For each user story/feature:
       - Break into 1-2 hour tasks (max 4 hours)
       - Define technical approach
       - Identify test requirements
       - Estimate effort in hours

       Document using work package template:
       - Task ID and name
       - Acceptance criteria
       - Test strategy (unit, integration)
       - Dependencies
       - Estimated hours

       Output: .aiwg/working/iteration-{N}/task-breakdown.md
       """
   )

   # Agent 2: Test Engineer
   Task(
       subagent_type="test-engineer",
       description="Define test-first strategy",
       prompt="""
       Read task breakdown

       For each task, define:
       - Test cases to write BEFORE implementation
       - Unit test scenarios
       - Integration test requirements
       - Acceptance test criteria
       - Expected test coverage

       Create test-first checklist:
       - Which tests block implementation start
       - Test data requirements
       - Mock/stub needs

       Output: .aiwg/working/iteration-{N}/test-first-strategy.md
       """
   )

   # Agent 3: Project Manager
   Task(
       subagent_type="project-manager",
       description="Create iteration plan with assignments",
       prompt="""
       Read task breakdown and test strategy

       Create iteration plan:
       1. Task sequence (considering dependencies)
       2. Owner assignments (load balancing)
       3. Critical path identification
       4. Risk mitigation tasks
       5. Daily milestone targets

       Calculate:
       - Total effort hours
       - Team capacity utilization
       - Iteration burndown forecast

       Template: $AIWG_ROOT/.../