flow-elaboration-to-construction

namespace	aiwg
name	flow-elaboration-to-construction
platforms	["all"]
description	Orchestrate Elaboration→Construction phase transition with iteration planning, team scaling, and full-scale development kickoff
commandHint	{"argumentHint":"[project-directory] [--guidance \"text\"] [--interactive]","allowedTools":"Task, Read, Write, Glob, TodoWrite","model":"sonnet","category":"sdlc-orchestration","orchestration":true,"modelRole":"coding","modelTier":"standard"}

Declarative Flow (#1539): This flow's orchestration is now also expressed as a declarative YAML Flow at flows/flow-elaboration-to-construction.playbook.yaml (source of truth for the step sequence + gates). This SKILL.md remains the discoverable trigger surface and prose reference. See epic #1534.

Elaboration → Construction Phase Transition Flow

You are the Core Orchestrator for the critical Elaboration→Construction phase transition.

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. Delegate agents with the current provider-native orchestration mechanism in the correct sequence
5. Synthesize results and finalize artifacts
6. Report completion with summary

Phase Transition Overview

From: Elaboration (architecture proven, risks retired) To: Construction (full-scale iterative development)

Key Milestone: Construction Phase Entry

Success Criteria:

• Architecture baselined and stable
• First 2 iterations planned with ready backlog
• Development process tailored and team trained
• CI/CD pipeline operational
• Iteration 0 (infrastructure) complete

Expected Duration: 1-2 weeks setup, 15-20 minutes orchestration

Natural Language Triggers

Users may say:

• "Transition to Construction"
• "Start Construction phase"
• "Begin building"
• "Move to Construction"
• "Scale up for Construction"
• "Start full development"

You recognize these as requests for this orchestration flow.

Parameter Handling

--guidance Parameter

Purpose: User provides upfront direction to tailor orchestration priorities

Examples:

--guidance "Team scaling from 5 to 20 developers, need extensive onboarding"
--guidance "Fast track, minimal documentation, focus on delivery"
--guidance "Offshore team joining, need extra process documentation"
--guidance "Complex integrations, need thorough environment setup"

How to Apply:

• Parse guidance for keywords: scaling, timeline, team, infrastructure
• Adjust agent assignments (add environment-engineer for complex setup)
• Modify artifact depth (comprehensive vs minimal documentation)
• Influence priority ordering (infrastructure vs process focus)

--interactive Parameter

Purpose: You ask 5-8 strategic questions to understand project context

Questions to Ask (if --interactive):

I'll ask 6 strategic questions to tailor the Construction transition to your needs:

Q1: What's your team scaling plan?
    (e.g., 5→20 developers, gradual vs immediate, onshore/offshore mix)

Q2: What are your infrastructure priorities?
    (Help me focus Iteration 0 on critical infrastructure needs)

Q3: What's your iteration cadence preference?
    (1 week, 2 weeks, 3 weeks - affects planning depth)

Q4: How mature is your CI/CD pipeline?
    (Determines infrastructure setup focus)

Q5: What's your biggest concern for Construction?
    (e.g., quality, velocity, team coordination, technical debt)

Q6: Do you need specialized environments?
    (e.g., compliance environments, performance testing, security scanning)

Based on your answers, I'll adjust:
- Agent assignments (infrastructure vs process focus)
- Iteration planning depth (detailed vs high-level)
- Onboarding materials (comprehensive vs minimal)
- Environment setup complexity

Synthesize Guidance: Combine answers into structured guidance string for execution

Artifacts to Generate

Primary Deliverables:

• ABM Validation Report: Elaboration exit criteria → .aiwg/reports/abm-validation-report.md
• Iteration 0 Completion Report: Infrastructure readiness → .aiwg/reports/iteration-0-completion.md
• Development Process Guide: Tailored process → .aiwg/planning/development-process-guide.md
• Iteration Plan - Sprint 1: First iteration → .aiwg/planning/iteration-plan-001.md
• Iteration Plan - Sprint 2: Second iteration → .aiwg/planning/iteration-plan-002.md
• Team Onboarding Guide: New member guide → .aiwg/team/onboarding-guide.md
• Architecture Stability Report: Change tracking → .aiwg/reports/architecture-stability-report.md
• Construction Readiness Report: Final go/no-go → .aiwg/reports/construction-readiness-report.md

Supporting Artifacts:

• Environment setup scripts
• CI/CD pipeline configurations
• Team RACI matrix updates
• Dual-track workflow setup

Multi-Agent Orchestration Workflow

Step 1: Validate Architecture Baseline Milestone (ABM)

Purpose: Verify Elaboration phase complete before starting Construction

Your Actions:

1. Check for Required Elaboration Artifacts:

   Read and verify presence of:
   - .aiwg/architecture/software-architecture-doc.md
   - .aiwg/architecture/adr/*.md
   - .aiwg/requirements/supplemental-specification.md
   - .aiwg/testing/master-test-plan.md
   - .aiwg/risks/risk-list.md (≥70% retired)
   - .aiwg/requirements/realizations/DES-UCR-*.md (behavioral specs — Layer 3)
   - .aiwg/architecture/method-contracts/DES-MIC-*.md (interface contracts)
   

2. Launch ABM Validation Agent:

   Task(
       subagent_type="project-manager",
       description="Validate Architecture Baseline Milestone criteria",
       prompt="""
       Read gate criteria from: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/flows/gate-criteria-by-phase.md
   
       Validate ABM criteria:
       - Software Architecture Document BASELINED
       - Executable architecture baseline OPERATIONAL
       - All P0/P1 architectural risks RETIRED/MITIGATED
       - ≥70% of all risks retired or mitigated
       - Requirements baseline ESTABLISHED (≥10 use cases)
       - Behavioral specifications COMPLETE (Layer 3):
         - ≥80% of architecturally significant UCs have realizations
         - State machine specs for stateful entities
         - Decision tables for complex branching logic
         - Method-level interface contracts for key components
       - Pseudo-code specifications COMPLETE for first iteration scope (Layer 4):
         - Algorithm specs for non-trivial logic
         - Error handling trees for critical paths
         - Data structure definitions with invariants
         - Spec-to-UC traceability chain validated
       - Master Test Plan APPROVED
       - Development Case tailored
       - Test environments OPERATIONAL
   
       Generate ABM Validation Report:
       - Status: PASS | FAIL
       - Criteria checklist with evidence
       - Behavioral spec coverage: X/Y use cases with realizations
       - Pseudo-code spec coverage: X/Y methods with specs
       - Decision: GO to Construction | NO-GO
       - Gaps (if NO-GO): List missing artifacts and specs
   
       Save to: .aiwg/reports/abm-validation-report.md
       """
   )
   

3. Decision Point:

   • If ABM PASS → Continue to Step 2
   • If ABM FAIL → Report gaps, recommend extending Elaboration
   • Escalate to user for executive decision if criteria partially met

Communicate Progress:

✓ Initialized ABM validation
⏳ Validating Elaboration exit criteria...
✓ ABM Validation complete: [PASS | FAIL]

Step 2: Execute Iteration 0 (Infrastructure Setup)

Purpose: Scale infrastructure for full Construction team

Your Actions:

1. Launch Infrastructure Setup Agents (parallel):

   # Agent 1: DevOps Engineer
   Task(
       subagent_type="devops-engineer",
       description="Setup CI/CD pipeline and environments",
       prompt="""
       Setup Construction infrastructure:
   
       CI/CD Pipeline:
       - Build automation (compile, package, containerize)
       - Test automation (unit, integration, E2E)
       - Deployment automation (dev, test, staging)
       - Quality gates (coverage, security scans)
   
       Environments:
       - Development: Per-developer or shared
       - Test: Shared integration environment
       - Staging: Production-like validation
       - Production: Provisioned (not deployed)
   
       Document setup in: .aiwg/working/construction/infrastructure/ci-cd-setup.md
       """
   )
   
   # Agent 2: Build Engineer
   Task(
       subagent_type="build-engineer",
       description="Configure build and artifact management",
       prompt="""
       Configure build infrastructure:
   
       - Build scripts and configurations
       - Dependency management
       - Artifact repository setup
       - Version control branching strategy
       - Build optimization (caching, parallelization)
   
       Document in: .aiwg/working/construction/infrastructure/build-config.md
       """
   )
   
   # Agent 3: Reliability Engineer
   Task(
       subagent_type="reliability-engineer",
       description="Setup monitoring and observability",
       prompt="""
       Configure monitoring infrastructure:
   
       - Application metrics (APM)
       - Infrastructure metrics
       - Log aggregation and retention
       - Alerting rules and escalation
       - Dashboard creation
       - SLO/SLI definitions
   
       Document in: .aiwg/working/construction/infrastructure/monitoring-setup.md
       """
   )
   
   # Agent 4: Environment Engineer
   Task(
       subagent_type="environment-engineer",
       description="Setup development environment and tools",
       prompt="""
       Configure development environment:
   
       - IDE configurations and plugins
       - Local development setup (Docker, etc)
       - Debugging tools
       - Code quality tools (linters, formatters)
       - Security scanning tools
       - Collaboration tools (Slack, Jira, Wiki)
   
       Create developer setup guide: .aiwg/working/construction/infrastructure/dev-environment-guide.md
       """
   )
   

2. Synthesize Infrastructure Report:

   Task(
       subagent_type="devops-engineer",
       description="Create Iteration 0 Completion Report",
       prompt="""
       Read all infrastructure setup documents:
       - .aiwg/working/construction/infrastructure/*.md
   
       Create comprehensive Iteration 0 Completion Report:
   
       1. Version Control (repository, branching, access)
       2. CI/CD Pipeline (build, test, deploy status)
       3. Environments (dev, test, staging operational status)
       4. Monitoring & Observability (metrics, logs, alerts)
       5. Collaboration Tools (chat, tracking, documentation)
       6. Security (secrets management, scanning)
       7. Developer Tools (IDE, debugging, quality)
   
       Include:
       - Checklist of completed items
       - Outstanding items (if any)
       - Access instructions for team
       - Overall status: COMPLETE | INCOMPLETE
   
       Save to: .aiwg/reports/iteration-0-completion.md
       """
   )
   

Communicate Progress:

⏳ Setting up Construction infrastructure (Iteration 0)...
  ✓ CI/CD pipeline configured
  ✓ Environments provisioned (dev, test, staging)
  ✓ Monitoring and observability operational
  ✓ Development tools configured
✓ Iteration 0 complete: Infrastructure ready for full team

Step 3: Tailor Development Process and Create Onboarding

Purpose: Finalize process for Construction and prepare team scaling

Your Actions:

1. Launch Process Definition Agents (parallel):

   # Agent 1: Project Manager
   Task(
       subagent_type="project-manager",
       description="Tailor Development Case for Construction",
       prompt="""
       Create Development Process Guide:
   
       Iteration Configuration:
       - Length: {1 week | 2 weeks | 3 weeks}
       - Ceremonies: Planning, Daily Standup, Review, Retrospective
       - Schedules and durations
   
       Roles and Responsibilities:
       - Update RACI matrix for Construction phase
       - Define approval processes
       - Establish escalation paths
   
       Workflow:
       - Definition of Ready (DoR)
       - Definition of Done (DoD)
       - Code review process
       - Deployment process
   
       Template: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/management/development-case-template.md
   
       Save to: .aiwg/planning/development-process-guide.md
       """
   )
   
   # Agent 2: Software Implementer
   Task(
       subagent_type="software-implementer",
       description="Create coding and design guidelines",
       prompt="""
       Document technical guidelines:
   
       Design Guidelines:
       - Architecture patterns to follow
       - Component boundaries
       - API design standards
       - Data model conventions
   
       Programming Guidelines:
       - Coding standards (language-specific)
       - Naming conventions
       - Error handling patterns
       - Logging standards
       - Documentation requirements
   
       Test Guidelines:
       - Test naming and organization
       - Coverage targets
       - Test data management
       - Mocking strategies
   
       Save to: .aiwg/working/construction/guidelines/
       """
   )
   
   # Agent 3: Human Resources Coordinator
   Task(
       subagent_type="human-resources-coordinator",
       description="Create team onboarding guide",
       prompt="""
       Create comprehensive onboarding guide for new team members:
   
       Week 1: Orientation
       - Project overview and vision
       - Architecture walkthrough
       - Development environment setup
       - Tool access and training
   
       Week 2: Ramp-up
       - Codebase tour
       - First starter task assignment
       - Pair programming sessions
       - Process training
   
       Resources:
       - Key documentation links
       - Team contacts and expertise areas
       - FAQ and troubleshooting
       - Escalation paths
   
       Checklists:
       - [ ] Accounts created
       - [ ] Tools installed
       - [ ] First commit completed
       - [ ] Process training attended
   
       Save to: .aiwg/team/onboarding-guide.md
       """
   )
   

2. Plan Team Training:

   Task(
       subagent_type="training-coordinator",
       description="Create training schedule for Construction team",
       prompt="""
       Design training program:
   
       Process Training (2-4 hours):
       - Development Case walkthrough
       - Ceremony participation
       - Tool usage (Jira, GitHub, Slack)
       - Quality standards
   
       Technical Training (as needed):
       - Architecture overview (SAD walkthrough)
       - Coding standards
       - Test strategy
       - Deployment process
   
       Training Materials:
       - Slide decks
       - Recorded sessions
       - Hands-on exercises
       - Knowledge checks
   
       Schedule:
       - Session dates and times
       - Attendee lists
       - Completion tracking
   
       Save to: .aiwg/team/training-schedule.md
       """
   )
   

Communicate Progress:

⏳ Tailoring development process...
  ✓ Development Process Guide created
  ✓ Technical guidelines documented
  ✓ Team onboarding guide prepared
  ✓ Training schedule planned
✓ Process ready for Construction team

Step 4: Plan First Two Iterations

Purpose: Create detailed iteration plans with ready backlog

Your Actions:

1. Assess Backlog Readiness:

   Task(
       subagent_type="requirements-analyst",
       description="Validate backlog readiness for Construction",
       prompt="""
       Assess backlog status:
   
       1. Count total backlog items
       2. Validate Definition of Ready (DoR) for each:
          - Use case documented
          - Acceptance criteria defined
          - Dependencies identified
          - Estimates provided
          - Risks assessed
   
       3. Calculate ready backlog size (story points)
       4. Assess backlog health:
          - Healthy: 1.5x-2x capacity ready
          - Marginal: 1x-1.5x capacity
          - Starved: <1x capacity
   
       Report:
       - Total items: {count}
       - Ready items: {count}
       - Ready size: {story points}
       - Health status: {HEALTHY | MARGINAL | STARVED}
   
       Save to: .aiwg/working/construction/backlog-assessment.md
       """
   )
   

2. Launch Iteration Planning Agents (sequential):

   # Iteration 1 Planning
   Task(
       subagent_type="project-manager",
       description="Plan Iteration 1 (conservative start)",
       prompt="""
       Create Iteration 1 Plan:
   
       Configuration:
       - Dates: {start} to {end}
       - Team capacity: {story points} (80% of full - ramp-up factor)
       - Buffer: 20% for unknowns
   
       Work Item Selection:
       - Prioritize: Must-have items first
       - Include: Architecture validation items
       - Avoid: High-risk items (save for Iteration 2+)
       - Target: {points} including buffer
   
       For each work item:
       - ID and name
       - Story points
       - Priority (MoSCoW)
       - Owner assignment
       - Dependencies
       - Acceptance criteria
   
       Objectives:
       - Validate development process
       - Establish team rhythm
       - Deliver first working features
   
       Template: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/management/iteration-plan-template.md
   
       Save to: .aiwg/planning/iteration-plan-001.md
       """
   )
   
   # Iteration 2 Planning
   Task(
       subagent_type="project-manager",
       description="Plan Iteration 2 (baseline velocity)",
       prompt="""
       Create Iteration 2 Plan:
   
       Configuration:
       - Dates: {start} to {end}
       - Team capacity: {story points} (100% - full capacity)
       - Buffer: 15% for unknowns
   
       Work Item Selection:
       - Continue priority order
       - Include: More complex items
       - Consider: Technical debt items
       - Target: {points} including buffer
   
       For each work item:
       - ID and name
       - Story points
       - Priority (MoSCoW)
       - Owner assignment
       - Dependencies
       - Acceptance criteria
   
       Objectives:
       - Establish baseline velocity
       - Tackle complex features
       - Refine estimation accuracy
   
       Template: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/management/iteration-plan-template.md
   
       Save to: .aiwg/planning/iteration-plan-002.md
       """
   )
   

Communicate Progress:

⏳ Planning first 2 iterations...
  ✓ Backlog assessed: {status}
  ✓ Iteration 1 planned: {points} points
  ✓ Iteration 2 planned: {points} points
✓ Iteration planning complete

Step 5: Setup Dual-Track Workflow

Purpose: Establish parallel Discovery and Delivery tracks

Your Actions:

1. Configure Dual-Track Process:

   Task(
       subagent_type="project-manager",
       description="Setup dual-track Discovery/Delivery workflow",
       prompt="""
       Configure dual-track workflow:
   
       Discovery Track (Iteration N+1):
       - Team: Requirements Analyst, Product Owner, Domain Experts
       - Focus: Prepare backlog for next iteration
       - Deliverables: Ready work items passing DoR
       - Timing: 1 iteration ahead of Delivery
   
       Delivery Track (Iteration N):
       - Team: Developers, Testers, Component Owners
       - Focus: Implement current iteration work
       - Deliverables: Working software increments
       - Timing: Current iteration
   
       Synchronization:
       - Handoff: End of Discovery N → Start of Delivery N
       - Gate: Definition of Ready (DoR)
       - Cadence: Every iteration boundary
   
       Shared Resources:
       - Software Architect (design reviews)
       - Security Architect (security reviews)
       - Project Manager (coordination)
   
       Document workflow in: .aiwg/planning/dual-track-workflow.md
       """
   )
   

2. Launch Initial Tracks:

   # Start Discovery for Iteration 3
   Task(
       subagent_type="requirements-analyst",
       description="Begin Discovery track for Iteration 3",
       prompt="""
       Initiate Discovery for Iteration 3:
   
       1. Review product backlog priorities
       2. Select candidate items for Iteration 3
       3. Begin requirement elaboration:
          - User stories
          - Acceptance criteria
          - Interface specifications
          - Data contracts
   
       4. Identify dependencies and risks
       5. Coordinate with architects for feasibility
   
       Target: Prepare {capacity * 1.5} story points
       Due: Before Iteration 2 ends
   
       Track progress in: .aiwg/working/discovery/iteration-003/
       """
   )
   
   # Confirm Delivery ready for Iteration 1
   Task(
       subagent_type="software-implementer",
       description="Confirm Delivery track ready for Iteration 1",
       prompt="""
       Validate Delivery readiness for Iteration 1:
   
       1. Confirm all Iteration 1 work items ready (DoR met)
       2. Verify team assignments complete
       3. Check development environment access
       4. Validate CI/CD pipeline operational
       5. Confirm daily standup scheduled
   
       Report readiness status
   
       Save to: .aiwg/working/delivery/iteration-001/readiness.md
       """
   )
   

Communicate Progress:

⏳ Setting up dual-track workflow...
  ✓ Discovery track configured (Iteration 3)
  ✓ Delivery track ready (Iteration 1)
  ✓ Synchronization points established
✓ Dual-track workflow operational

Step 6: Monitor Architecture Stability

Purpose: Ensure architecture remains stable during Construction startup

Your Actions:

Task(
    subagent_type="architecture-designer",
    description="Assess architecture stability for Construction",
    prompt="""
    Analyze architecture stability:

    1. Review architectural changes since ABM:
       - Count new ADRs created
       - Identify component boundary changes
       - Check technology stack modifications
       - Assess integration changes

    2. Calculate metrics:
       - Architectural Change Rate: % changes (target <10%)
       - ADR Frequency: ADRs per iteration
       - Component Violations: boundary breaches (target 0)
       - Prototype Divergence: % rewritten (target <30%)

    3. Identify risks:
       - Architecture drift indicators
       - Instability patterns
       - Technical debt accumulation

    4. Recommendations:
       - Continue as-is
       - Conduct architecture review
       - Adjust Construction approach

    Generate Architecture Stability Report:
    - Overall status: STABLE | UNSTABLE
    - Metrics with targets
    - Risk assessment
    - Action items

    Save to: .aiwg/reports/architecture-stability-report.md
    """
)

Communicate Progress:

⏳ Monitoring architecture stability...
✓ Architecture stability: [STABLE | UNSTABLE]
  - Change rate: {X}% (target <10%)
  - Component violations: {N} (target 0)

Step 7: Generate Construction Readiness Report

Purpose: Final readiness assessment and go/no-go decision

Your Actions:

Task(
    subagent_type="project-manager",
    description="Generate Construction Phase Readiness Report",
    prompt="""
    Read all transition artifacts:
    - .aiwg/reports/abm-validation-report.md
    - .aiwg/reports/iteration-0-completion.md
    - .aiwg/planning/development-process-guide.md
    - .aiwg/planning/iteration-plan-001.md
    - .aiwg/planning/iteration-plan-002.md
    - .aiwg/team/onboarding-guide.md
    - .aiwg/reports/architecture-stability-report.md

    Generate comprehensive Construction Readiness Report:

    1. Overall Status
       - Construction Readiness: READY | NOT READY
       - Decision: PROCEED | DEFER

    2. Gate Validation (6 criteria)
       - ABM Complete: {status}
       - Infrastructure Ready: {status}
       - Process Defined: {status}
       - Iterations Planned: {status}
       - Dual-Track Setup: {status}
       - Architecture Stable: {status}

    3. Team Readiness
       - Team size and scaling status
       - Training completion
       - Onboarding materials ready

    4. Infrastructure Readiness
       - CI/CD operational
       - Environments ready
       - Monitoring configured

    5. Backlog Readiness
       - Ready backlog size vs capacity
       - DoR compliance
       - First 2 iterations planned

    6. Decision and Next Steps
       - If READY: Kickoff instructions
       - If NOT READY: Gap closure plan

    7. Success Metrics to Track
       - Velocity targets
       - Quality targets
       - Schedule targets

    Save to: .aiwg/reports/construction-readiness-report.md
    """
)

Present Summary to User:

# You present this directly (not via agent)

Read .aiwg/reports/construction-readiness-report.md

Present summary:
─────────────────────────────────────────────
Construction Phase Readiness Assessment
─────────────────────────────────────────────

**Overall Status**: {READY | NOT READY}
**Decision**: {PROCEED | DEFER}

**Gate Criteria Status**:
✓ Architecture Baseline Milestone: PASS
✓ Infrastructure (Iteration 0): COMPLETE
✓ Development Process: READY
✓ Iteration Planning: COMPLETE (2 sprints)
✓ Dual-Track Workflow: OPERATIONAL
✓ Architecture Stability: STABLE

**Team Scaling**:
- Elaboration team: {N} members
- Construction team: {M} members
- Onboarding status: READY

**Infrastructure**:
- CI/CD Pipeline: OPERATIONAL
- Environments: Dev, Test, Staging READY
- Monitoring: CONFIGURED

**Backlog**:
- Ready items: {X} story points
- Capacity ratio: {Y}x (target 1.5x-2x)
- Iteration 1: {Z} points planned
- Iteration 2: {W} points planned

**Artifacts Generated**:
- ABM Validation Report (.aiwg/reports/abm-validation-report.md)
- Iteration 0 Completion (.aiwg/reports/iteration-0-completion.md)
- Development Process Guide (.aiwg/planning/development-process-guide.md)
- Iteration Plans (.aiwg/planning/iteration-plan-*.md)
- Onboarding Guide (.aiwg/team/onboarding-guide.md)
- Architecture Stability (.aiwg/reports/architecture-stability-report.md)
- Construction Readiness (.aiwg/reports/construction-readiness-report.md)

**Next Steps**:
- Kick off Iteration 1: {date}
- First daily standup: {date}
- Discovery continues for Iteration 3
- Monitor velocity and quality metrics

─────────────────────────────────────────────

Quality Gates

Before marking workflow complete, verify:

• All required artifacts generated and reviewed
• Infrastructure validated operational (Iteration 0)
• Team process defined and training scheduled
• First 2 iterations planned with ready backlog
• Dual-track workflow configured
• Architecture stability confirmed
• Construction readiness validated

User Communication

At start: Confirm understanding and list artifacts to generate

Understood. I'll orchestrate the Elaboration → Construction transition.

This will generate:
- ABM Validation Report
- Iteration 0 Completion Report
- Development Process Guide
- Iteration Plans (first 2 sprints)
- Team Onboarding Guide
- Architecture Stability Report
- Construction Readiness Report

I'll coordinate multiple agents for infrastructure setup and planning.
Expected duration: 15-20 minutes.

Starting orchestration...

During: Update progress with clear indicators

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

At end: Summary report with artifact locations and status

Error Handling

If ABM Not Met:

❌ Elaboration phase incomplete - cannot proceed to Construction

Gaps identified:
- {list missing artifacts or incomplete criteria}

Recommendation: Extend Elaboration
- Complete missing artifacts
- Re-run: /flow-inception-to-elaboration

Contact Software Architect for architecture completion.

If Infrastructure Not Ready:

❌ Iteration 0 incomplete - infrastructure not operational

Issues:
- {list infrastructure gaps}

Actions:
1. Complete infrastructure setup
2. Validate CI/CD pipeline
3. Confirm environment access

Impact: Construction blocked until infrastructure ready.

If Backlog Starved:

⚠️ Backlog health: STARVED ({ratio}x capacity)

Ready backlog insufficient for smooth Construction start.

Actions:
1. Accelerate Discovery track
2. Simplify requirements for faster preparation
3. Consider starting with reduced team

Risk: Delivery team may be blocked waiting for work.

If Architecture Unstable:

⚠️ Architecture stability: UNSTABLE

Metrics:
- Change rate: {X}% (target <10%)
- Violations: {N}

Recommendation: Architecture review needed
- Stabilize architecture before scaling team
- Document pending decisions as ADRs
- Consider architecture refactoring in Iteration 1

Risk: Continued instability will impact Construction velocity.

Success Criteria

This orchestration succeeds when:

• Architecture Baseline Milestone validated (ABM complete)
• Iteration 0 infrastructure setup COMPLETE
• Development process tailored and team trained
• First 2 iterations planned with ready backlog
• Dual-track workflow OPERATIONAL
• Architecture stability confirmed (<10% change)
• Construction Phase Readiness Report shows READY
• Complete audit trails archived

Metrics to Track

During orchestration, track:

• Team scaling time: Days to onboard new members
• Infrastructure setup time: Iteration 0 completion
• Training completion rate: % of team trained
• Backlog readiness: Ratio to team capacity
• Architecture stability: % changes since ABM
• Cycle time: Transition duration (target: 1-2 weeks, orchestration: 15-20 min)

References

Templates (via $AIWG_ROOT):

• Development Case: templates/management/development-case-template.md
• Iteration Plan: templates/management/iteration-plan-template.md
• Programming Guidelines: templates/environment/programming-guidelines-template.md
• Design Guidelines: templates/environment/design-guidelines-template.md
• Test Guidelines: templates/environment/test-guidelines-template.md

Gate Criteria:

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

Related Flows:

• commands/flow-iteration-dual-track.md
• commands/flow-discovery-track.md
• commands/flow-delivery-track.md

Multi-Agent Pattern:

• docs/multi-agent-documentation-pattern.md

Orchestrator Architecture:

• docs/orchestrator-architecture.md