aiwg 2024.12.3 → 2026.1.3

package/plugins/sdlc/commands/flow-elaboration-to-construction.md

@@ -0,0 +1,1005 @@
+---
+description: Orchestrate Elaboration→Construction phase transition with iteration planning, team scaling, and full-scale development kickoff
+category: sdlc-orchestration
+argument-hint: [project-directory] [--guidance "text"] [--interactive]
+allowed-tools: Task, Read, Write, Glob, TodoWrite
+orchestration: true
+model: opus
+---
+
+# 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. **Launch agents via Task tool** in 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)
+   ```
+
+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)
+       - 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
+       """
+   )
+   ```
+
+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`