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

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

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:

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)

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)
    - Master Test Plan APPROVED
    - Development Case tailored
    - Test environments OPERATIONAL

    Generate ABM Validation Report:
    - Status: PASS | FAIL
    - Criteria checklist with evidence
    - Decision: GO to Construction | NO-GO
    - Gaps (if NO-GO): List missing artifacts

    Save to: .aiwg/reports/abm-validation-report.md
    """
)

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:

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

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:

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

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:

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

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:

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

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

/flow-elaboration-to-construction

Elaboration → Construction Phase Transition Flow

Your Role

Phase Transition Overview

Natural Language Triggers

Parameter Handling

--guidance Parameter

--interactive Parameter

Artifacts to Generate

Multi-Agent Orchestration Workflow

Step 1: Validate Architecture Baseline Milestone (ABM)

Step 2: Execute Iteration 0 (Infrastructure Setup)

Step 3: Tailor Development Process and Create Onboarding

Step 4: Plan First Two Iterations

Step 5: Setup Dual-Track Workflow

Step 6: Monitor Architecture Stability

Step 7: Generate Construction Readiness Report

Quality Gates

User Communication

Error Handling

Success Criteria

Metrics to Track

References