jmagly/flow-construction-to-transition

<!-- AIWG-SKILL-CALLOUT -->

Skill access pattern (post-kernel-pivot, 2026.5+)

Skill names referenced in this document are AIWG skills, not slash commands. Most are not kernel-listed and cannot be invoked as /skill-name by the platform. Reach them via:

aiwg discover "<capability>"
aiwg show skill <name>

Only kernel-listed skills (aiwg-doctor, aiwg-refresh, aiwg-status, aiwg-help, use, steward) are directly invokable as slash commands. See skill-discovery rule.

Construction → Transition Phase Transition Flow

You are the Core Orchestrator for the critical Construction→Transition 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: Construction (feature-complete, tested, deployment-ready) To: Transition (production deployed, users trained, support operational)

Key Milestone: Product Release Milestone (PRM)

Success Criteria:

• Production deployment successful and stable
• Users trained and actively using system
• Support and operations teams operational
• Hypercare period completed without critical issues
• Business value validated

Expected Duration: 2-4 weeks (typical), 20-30 minutes orchestration

Natural Language Triggers

Users may say:

• "Transition to production"
• "Start Transition phase"
• "Prepare for deployment"
• "Move to Transition"
• "Ready to deploy"
• "Deploy to production"
• "Begin production rollout"
• "Start hypercare period"

You recognize these as requests for this orchestration flow.

Parameter Handling

--guidance Parameter

Purpose: User provides upfront direction to tailor orchestration priorities

Examples:

--guidance "High-risk deployment, need extensive validation and rollback plans"
--guidance "Limited support team, extra training and documentation needed"
--guidance "Performance critical, validate SLAs thoroughly before cutover"
--guidance "Phased rollout required, start with pilot users only"

How to Apply:

• Parse guidance for keywords: rollback, training, performance, phased, pilot
• Adjust agent assignments (add reliability-engineer for performance focus)
• Modify deployment strategy (phased vs. big-bang based on risk tolerance)
• Influence validation depth (comprehensive vs. streamlined based on risk)

--interactive Parameter

Purpose: You ask 6-8 strategic questions to understand deployment context

Questions to Ask (if --interactive):

I'll ask 8 strategic questions to tailor the Transition to your needs:

Q1: What deployment strategy do you prefer?
    (e.g., big-bang, phased/canary, blue-green, feature toggles)

Q2: How critical is zero-downtime deployment?
    (Helps me plan cutover strategy and rollback procedures)

Q3: What's your support team's readiness level?
    (Determines training depth and handover timeline)

Q4: What are your rollback criteria?
    (Define when to pull back vs. fix forward)

Q5: How long should the hypercare period be?
    (7 days minimum, 14 days standard, 30 days for critical systems)

Q6: Are there specific compliance requirements for production?
    (e.g., SOC2 audit trails, HIPAA logging, PCI-DSS controls)

Q7: What's your user adoption strategy?
    (All at once, pilot group first, gradual onboarding)

Q8: What business metrics define success?
    (KPIs to validate during hypercare and PRM review)

Based on your answers, I'll adjust:
- Deployment strategy and validation depth
- Support training intensity
- Hypercare monitoring focus
- Success criteria thresholds

Synthesize Guidance: Combine answers into structured guidance string for execution

Artifacts to Generate

Primary Deliverables:

• Production Deployment Report: Deployment execution and validation → .aiwg/deployment/production-deployment-report.md
• User Training Report: Training delivery and UAT results → .aiwg/deployment/user-training-report.md
• Support Handover Report: Support team readiness → .aiwg/deployment/support-handover-report.md
• Operations Handover Report: Ops team readiness → .aiwg/deployment/operations-handover-report.md
• Hypercare Daily Reports: Production monitoring → .aiwg/reports/hypercare-day-*.md
• PRM Report: Milestone readiness assessment → .aiwg/reports/prm-report.md

Supporting Artifacts:

• Infrastructure Readiness Report
• Operational Runbooks
• Support Knowledge Base
• Complete audit trails

Multi-Agent Orchestration Workflow

Step 1: Validate Construction Exit Criteria (OCM)

Purpose: Verify Operational Capability Milestone achieved before starting Transition

Your Actions:

1. Check for Required Construction Artifacts:

   Read and verify presence of:
   - .aiwg/deployment/deployment-plan.md
   - .aiwg/deployment/release-notes.md
   - .aiwg/deployment/support-runbook.md
   - .aiwg/testing/test-evaluation-summary.md
   - .aiwg/deployment/bill-of-materials.md
   

2. Launch Gate Check Agent:

   Task(
       subagent_type="project-manager",
       description="Validate Construction gate (OCM) criteria",
       prompt="""
       Read gate criteria from: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/flows/gate-criteria-by-phase.md
   
       Validate OCM criteria:
       - All planned features IMPLEMENTED (100% Must Have, ≥80% Should Have)
       - All acceptance tests PASSING (≥98% pass rate)
       - Test coverage targets MET (unit ≥80%, integration ≥70%, e2e ≥50%)
       - Zero P0 (Show Stopper) defects open
       - Zero P1 (High) defects open OR all have approved waivers
       - Performance tests PASSING (response time, throughput, concurrency)
       - Security tests PASSING (no High/Critical vulnerabilities)
       - CI/CD pipeline OPERATIONAL
       - Deployment plan COMPLETE and APPROVED
       - Operational Readiness Review (ORR) PASSED
   
       Generate OCM Validation Report:
       - Status: PASS | FAIL
       - Criteria checklist with results
       - Decision: GO to Transition | NO-GO
       - Gaps (if NO-GO): List missing artifacts
   
       Save to: .aiwg/reports/ocm-validation-report.md
       """
   )
   

3. Decision Point:

   • If OCM PASS → Continue to Step 2
   • If OCM FAIL → Report gaps to user, recommend flow-elaboration-to-construction to complete Construction
   • Escalate to user for executive decision if criteria partially met

Communicate Progress:

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

Step 2: Prepare Production Environment

Purpose: Ensure production infrastructure is provisioned, configured, and validated

Your Actions:

1. Read Infrastructure Context:

   Read:
   - .aiwg/deployment/infrastructure-definition.md
   - .aiwg/deployment/deployment-environment.md
   - .aiwg/architecture/software-architecture-doc.md (deployment view)
   

2. Launch Infrastructure Validation Agents (parallel):

   # Agent 1: DevOps Engineer
   Task(
       subagent_type="devops-engineer",
       description="Validate production infrastructure readiness",
       prompt="""
       Read infrastructure definition and deployment environment docs
   
       Validate production environment:
       - Infrastructure provisioned (compute, storage, network)
       - Capacity validated (expected load + 20% buffer)
       - High availability configured (redundancy, failover)
       - Scalability tested (autoscaling operational)
       - Network configuration (load balancers, CDN, DNS)
   
       Document infrastructure status:
       - Environment provisioning status
       - Capacity test results
       - HA/DR configuration
       - Outstanding issues
   
       Save to: .aiwg/working/transition/infrastructure-readiness.md
       """
   )
   
   # Agent 2: Security Architect
   Task(
       subagent_type="security-architect",
       description="Validate production security configuration",
       prompt="""
       Read security architecture and deployment docs
   
       Validate security hardening:
       - Firewall rules configured (least privilege)
       - SSL/TLS certificates valid (no expiry < 30 days)
       - Access controls configured (RBAC, audit logging)
       - Secrets management operational (vault, KMS)
       - Encryption enabled (at-rest, in-transit)
       - Security scan results (no High/Critical vulnerabilities)
   
       Document security status
   
       Save to: .aiwg/working/transition/security-validation.md
       """
   )
   
   # Agent 3: Reliability Engineer
   Task(
       subagent_type="reliability-engineer",
       description="Validate monitoring and observability",
       prompt="""
       Validate monitoring infrastructure:
       - Application metrics configured
       - Infrastructure metrics configured
       - Dashboards operational (list key dashboards)
       - Alerting configured and tested
       - Log aggregation working
       - SLIs/SLOs defined
       - Backup procedures automated
       - Disaster recovery validated
   
       Document observability status
   
       Save to: .aiwg/working/transition/observability-readiness.md
       """
   )
   

3. Synthesize Infrastructure Readiness Report:

   Task(
       subagent_type="deployment-manager",
       description="Create Production Environment Readiness Report",
       prompt="""
       Read all infrastructure validation reports:
       - .aiwg/working/transition/infrastructure-readiness.md
       - .aiwg/working/transition/security-validation.md
       - .aiwg/working/transition/observability-readiness.md
   
       Synthesize comprehensive readiness report covering:
       - Infrastructure provisioning status
       - Capacity and scalability validation
       - Security hardening status
       - Monitoring and observability
       - Backup and disaster recovery
       - Overall readiness: READY | NOT READY
   
       Output: .aiwg/deployment/production-environment-readiness-report.md
       """
   )
   

Communicate Progress:

✓ OCM validation complete
⏳ Validating production environment...
  ✓ Infrastructure provisioned and validated
  ✓ Security hardening complete
  ✓ Monitoring and observability operational
✓ Production environment: READY

Step 3: Execute Production Deployment

Purpose: Deploy application to production using validated deployment plan

Your Actions:

1. Select Deployment Strategy:

   Task(
       subagent_type="deployment-manager",
       description="Select and plan deployment strategy",
       prompt="""
       Read deployment plan: .aiwg/deployment/deployment-plan.md
       Consider guidance: {user-guidance if provided}
   
       Select optimal strategy:
       - Big Bang: Simple but high risk (for low-traffic systems)
       - Phased/Canary: Gradual rollout (for risk mitigation)
       - Blue-Green: Parallel environments (for instant rollback)
       - Feature Toggle: Dark launch (for maximum control)
   
       Document selected strategy and rationale
       Define rollback criteria and procedures
   
       Output: .aiwg/working/transition/deployment-strategy.md
       """
   )
   

2. Execute Deployment (coordinate multiple agents):

   # Pre-deployment
   Task(
       subagent_type="deployment-manager",
       description="Execute pre-deployment checklist",
       prompt="""
       Validate pre-deployment:
       - Deployment window scheduled and communicated
       - Code freeze active
       - Deployment team assembled
       - Rollback plan validated
       - Stakeholders notified
   
       Document readiness: .aiwg/working/transition/pre-deployment-checklist.md
       """
   )
   
   # Deployment execution
   Task(
       subagent_type="devops-engineer",
       description="Execute production deployment",
       prompt="""
       Deploy to production following selected strategy:
       1. Execute deployment scripts/automation
       2. Run database migrations (if applicable)
       3. Update configuration (env vars, feature flags)
       4. Deploy application (code, containers, artifacts)
       5. Validate health checks
   
       Monitor deployment progress
       Document any issues encountered
   
       Output: .aiwg/working/transition/deployment-execution-log.md
       """
   )
   
   # Post-deployment validation
   Task(
       subagent_type="reliability-engineer",
       description="Validate post-deployment health",
       prompt="""
       Validate deployment success:
       - Smoke tests passing (critical paths)
       - Monitoring dashboards green
       - Error rates normal (<0.1%)
       - Performance metrics acceptable
       - User login tested
       - Key features tested
   
       Decision: SUCCESS | ISSUES DETECTED | ROLLBACK
   
       Output: .aiwg/working/transition/post-deployment-validation.md
       """
   )
   

3. Generate Deployment Report:

   Task(
       subagent_type="deployment-manager",
       description="Create Production Deployment Report",
       prompt="""
       Read all deployment artifacts:
       - Deployment strategy
       - Pre-deployment checklist
       - Deployment execution log
       - Post-deployment validation
   
       Generate comprehensive deployment report:
       - Deployment strategy and rationale
       - Execution timeline
       - Validation results
       - Issues and resolutions
       - Deployment outcome: SUCCESS | PARTIAL SUCCESS | FAILED | ROLLED BACK
       - Next steps
   
       Output: .aiwg/deployment/production-deployment-report.md
       """
   )
   

Communicate Progress:

⏳ Executing production deployment...
  ✓ Pre-deployment checklist complete
  ✓ Deployment executed successfully
  ✓ Post-deployment validation: PASSED
✓ Production deployment: SUCCESS

Step 4: Conduct User Training and UAT

Purpose: Train users and validate acceptance in production

Your Actions:

1. Prepare Training Materials:

   Task(
       subagent_type="training-lead",
       description="Prepare and validate training materials",
       prompt="""
       Create/validate training materials:
       - User guides (role-based)
       - Quick reference cards
       - Video tutorials (if needed)
       - Online help documentation
       - FAQs
   
       Ensure materials cover all user roles
       Validate accuracy against deployed system
   
       Output: .aiwg/working/transition/training-materials-status.md
       """
   )
   

2. Deliver Training:

   Task(
       subagent_type="training-lead",
       description="Coordinate user training delivery",
       prompt="""
       Plan and track training delivery:
       - Schedule instructor-led sessions
       - Set up hands-on practice environments
       - Deploy self-paced e-learning
       - Schedule office hours for Q&A
   
       Track participation and completion
       Gather feedback scores
   
       Output: .aiwg/working/transition/training-delivery-status.md
       """
   )
   

3. Execute UAT:

   Task(
       subagent_type="requirements-analyst",
       description="Coordinate User Acceptance Testing",
       prompt="""
       Read Product Acceptance Plan template
   
       Coordinate UAT execution:
       - Identify key users per role
       - Define UAT scenarios (10+ critical workflows)
       - Track scenario execution
       - Capture user feedback
       - Document issues found
   
       Calculate UAT metrics:
       - Pass rate (target: ≥90%)
       - User satisfaction (target: ≥4/5)
       - Critical issues found
   
       Output: .aiwg/working/transition/uat-results.md
       """
   )
   

4. Generate Training and Acceptance Report:

   Task(
       subagent_type="product-owner",
       description="Create User Training and Acceptance Report",
       prompt="""
       Synthesize training and UAT results:
       - Training completion rates
       - Knowledge check results
       - UAT pass rates
       - User satisfaction scores
       - User adoption metrics
       - Acceptance decision: ACCEPTED | CONDITIONAL | REJECTED
   
       Output: .aiwg/deployment/user-training-report.md
       """
   )
   

Communicate Progress:

⏳ Conducting user training and acceptance...
  ✓ Training materials prepared
  ✓ Training delivered (85% completion)
  ✓ UAT completed (92% pass rate)
  ✓ User satisfaction: 4.2/5
✓ User acceptance: ACCEPTED

Step 5: Execute Support and Operations Handover

Purpose: Formally hand over to support and operations teams

Your Actions:

1. Support Team Training:

   Task(
       subagent_type="support-lead",
       description="Train and validate support team readiness",
       prompt="""
       Train support team on:
       - System architecture overview
       - Common user issues and resolutions
       - Runbook procedures
       - Incident escalation paths
       - Support tools and ticketing
   
       Validate readiness:
       - Practice incidents resolved (≥3)
       - Runbook effectiveness tested
       - Knowledge base populated
   
       Output: .aiwg/working/transition/support-training-status.md
       """
   )
   

2. Operations Team Training:

   Task(
       subagent_type="operations-lead",
       description="Train and validate operations team readiness",
       prompt="""
       Train operations team on:
       - Deployment procedures
       - Monitoring and alerting
       - Incident response
       - Backup and restore
       - Scaling procedures
   
       Validate readiness:
       - Independent deployment successful
       - Alert response tested
       - Backup/restore validated
   
       Output: .aiwg/working/transition/operations-training-status.md
       """
   )
   

3. Formal Handover:

   Task(
       subagent_type="deployment-manager",
       description="Coordinate formal handover",
       prompt="""
       Coordinate handover meetings:
       - Support handover meeting conducted
       - Operations handover meeting conducted
       - Known issues reviewed
       - Escalation procedures confirmed
   
       Obtain signoffs:
       - Support Lead signoff
       - Operations Lead signoff
   
       Document handover status:
       - Support: ACCEPTED | CONDITIONAL | NOT ACCEPTED
       - Operations: ACCEPTED | CONDITIONAL | NOT ACCEPTED
   
       Output: .aiwg/deployment/support-handover-report.md
       Output: .aiwg/deployment/operations-handover-report.md
       """
   )
   

Communicate Progress:

⏳ Executing support and operations handover...
  ✓ Support team trained and ready
  ✓ Operations team trained and ready
  ✓ Support Lead signoff: OBTAINED
  ✓ Operations Lead signoff: OBTAINED
✓ Handover complete: ACCEPTED

Step 6: Enter Hypercare Period

Purpose: Conduct 7-14 days of intensive monitoring and rapid response

Your Actions:

1. Initialize Hypercare Monitoring:

   Task(
       subagent_type="reliability-engineer",
       description="Set up hypercare monitoring",
       prompt="""
       Initialize hypercare period:
       - Duration: 7-14 days (based on system criticality)
       - Monitoring intensity: ELEVATED
       - Response SLAs: ACCELERATED
       - Daily standup schedule: SET
   
       Define success criteria:
       - Zero P0/P1 incidents
       - Error rate <0.1%
       - Performance within SLA
       - User adoption on track
   
       Output: .aiwg/working/transition/hypercare-plan.md
       """
   )
   

2. Daily Hypercare Monitoring (repeat daily):

   Task(
       subagent_type="reliability-engineer",
       description="Daily hypercare monitoring report",
       prompt="""
       Monitor and report daily:
   
       Production Stability:
       - Incidents (P0/P1/P2/P3 counts)
       - Error rates and trends
       - Uptime percentage
       - Performance metrics (p50, p95, p99)
   
       User Adoption:
       - Active users (DAU/WAU)
       - Feature usage statistics
       - User feedback themes
   
       Support Effectiveness:
       - Ticket volume and categories
       - Resolution times (MTTR)
       - Escalations to development
   
       Decision: CONTINUE | EXTEND | CONCLUDE
   
       Output: .aiwg/reports/hypercare-day-{day}.md
       """
   )
   

3. Hypercare Review (Day 7 and Day 14):

   Task(
       subagent_type="deployment-manager",
       description="Hypercare period review",
       prompt="""
       Review hypercare metrics:
       - Production stability validated
       - User adoption on track
       - Support effectiveness confirmed
       - No critical issues outstanding
   
       Decision:
       - CONCLUDE hypercare (ready for PRM)
       - EXTEND hypercare (specify duration and criteria)
       - ISSUES DETECTED (return to remediation)
   
       Output: .aiwg/reports/hypercare-review.md
       """
   )
   

Communicate Progress:

⏳ Hypercare period (Day 1-14)...
  Day 1: ✓ Stable (0 incidents, 99.99% uptime)
  Day 3: ✓ Stable (1 P3 incident resolved)
  Day 7: ✓ Mid-review: CONTINUE
  Day 14: ✓ Final review: READY FOR PRM
✓ Hypercare complete: Production stable

Step 7: Validate Product Release Milestone (PRM)

Purpose: Formal PRM review to decide project completion

Your Actions:

1. Validate PRM Criteria:

   Task(
       subagent_type="project-manager",
       description="Validate PRM gate criteria",
       prompt="""
       Read gate criteria: $AIWG_ROOT/.../flows/gate-criteria-by-phase.md (Transition section)
   
       Validate all PRM criteria:
   
       1. Production Deployment
          - [ ] Deployment successful and stable
          - [ ] Hypercare completed (7-14 days)
   
       2. Production Stability
          - [ ] Uptime meets SLA
          - [ ] Zero P0/P1 incidents
          - [ ] Performance within targets
   
       3. User Adoption
          - [ ] Users trained (≥80%)
          - [ ] UAT passed
          - [ ] User satisfaction ≥4/5
          - [ ] Active user adoption on track
   
       4. Support Handover
          - [ ] Support team operational
          - [ ] Support Lead signoff obtained
   
       5. Operations Handover
          - [ ] Operations team operational
          - [ ] Operations Lead signoff obtained
   
       6. Business Value
          - [ ] Success metrics tracking
          - [ ] ROI forecast positive
   
       Report status: PASS | CONDITIONAL PASS | FAIL
   
       Output: .aiwg/reports/prm-criteria-validation.md
       """
   )
   

2. Generate PRM Report:

   Task(
       subagent_type="project-manager",
       description="Generate Product Release Milestone Report",
       prompt="""
       Read all Transition artifacts:
       - Production deployment report
       - User training and acceptance reports
       - Support/Operations handover reports
       - Hypercare reports
       - PRM criteria validation
   
       Generate comprehensive PRM Report:
   
       1. Overall Status
          - PRM Status: PASS | CONDITIONAL PASS | FAIL
          - Decision: PROJECT COMPLETE | EXTENDED HYPERCARE | ISSUES DETECTED
   
       2. Criteria Validation (detailed breakdown)
   
       3. Signoff Checklist
          - [ ] Executive Sponsor
          - [ ] Product Owner
          - [ ] Deployment Manager
          - [ ] Support Lead
          - [ ] Operations Lead
          - [ ] Reliability Engineer
   
       4. Business Value Validation
          - Success metrics vs. baseline
          - ROI forecast
          - Stakeholder satisfaction
   
       5. Lessons Learned
          - What went well
          - What could improve
          - Action items
   
       6. Next Steps
          - Project closure activities
          - Transition to BAU
   
       Output: .aiwg/reports/prm-report.md
       """
   )
   

3. Present PRM Summary to User:

   # You present this directly (not via agent)
   
   Read .aiwg/reports/prm-report.md
   
   Present summary:
   ─────────────────────────────────────────────
   Product Release Milestone Review
   ─────────────────────────────────────────────
   
   **Overall Status**: {PASS | CONDITIONAL PASS | FAIL}
   **Decision**: {PROJECT COMPLETE | EXTENDED HYPERCARE | ISSUES DETECTED}
   
   **Criteria Status**:
   ✓ Production Deployment: PASS
     - Successfully deployed, 14 days stable
   
   ✓ Production Stability: PASS
     - Uptime: 99.97% (target: ≥99.9%)
     - P0/P1 Incidents: 0
   
   ✓ User Adoption: PASS
     - Users trained: 92% (target: ≥80%)
     - UAT passed: 95% scenarios
     - User satisfaction: 4.3/5
   
   ✓ Support Handover: PASS
     - Support team operational
     - MTTR: 2.5 hours (target: <4 hours)
   
   ✓ Operations Handover: PASS
     - Operations team validated
     - Independent deployment successful
   
   ✓ Business Value: ON TRACK
     - Early metrics positive
     - ROI forecast: Meeting projections
   
   **Artifacts Generated**:
   - Production Deployment Report (.aiwg/deployment/production-deployment-report.md)
   - User Training Report (.aiwg/deployment/user-training-report.md)
   - Support Handover Report (.aiwg/deployment/support-handover-report.md)
   - Operations Handover Report (.aiwg/deployment/operations-handover-report.md)
   - Hypercare Reports (.aiwg/reports/hypercare-day-*.md)
   - PRM Report (.aiwg/reports/prm-report.md)
   
   **Next Steps**:
   - Formal project closure
   - Transition to Business As Usual (BAU)
   - Team celebration and recognition
   - Final retrospective scheduled
   
   ─────────────────────────────────────────────
   

Communicate Progress:

⏳ Conducting PRM validation...
✓ PRM criteria validated: PASS (6/6 criteria met)
✓ PRM Report generated: .aiwg/reports/prm-report.md
✓ PROJECT COMPLETE - Ready for closure

Quality Gates

Before marking workflow complete, verify:

• [ ] All required artifacts generated and BASELINED
• [ ] Production deployment successful and stable
• [ ] User acceptance validated
• [ ] Support/Operations handover accepted
• [ ] Hypercare period completed successfully
• [ ] PRM criteria validated: PASS or CONDITIONAL PASS

User Communication

At start: Confirm understanding and list artifacts to generate

Understood. I'll orchestrate the Construction → Transition phase.

This will generate:
- Production Deployment Report
- User Training and Acceptance Reports
- Support and Operations Handover Reports
- Hypercare Daily Reports (7-14 days)
- PRM Report

I'll coordinate deployment, training, handover, and monitoring.
Expected duration: 20-30 minutes orchestration (2-4 weeks actual).

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 (see Step 7.3 above)

Error Handling

If OCM Not Met:

❌ Construction phase incomplete - cannot proceed to Transition

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

Recommendation: Complete Construction first
- Run: /flow-elaboration-to-construction
- Or: Complete missing artifacts manually

Contact Product Owner for project status decision.

If Deployment Failed:

❌ Production deployment failed

Failure point: {deployment stage}
Error: {error description}

Actions:
1. Execute rollback plan
2. Investigate root cause
3. Fix issues in Construction
4. Re-plan deployment

Impact: Cannot proceed to user training until deployment successful.

Escalating to user for decision...

If Production Unstable:

⚠️ Production instability detected

Issues:
- P0/P1 Incidents: {count}
- Error rate: {percentage}%
- Performance degradation: {metrics}

Recommendation:
- Fix forward (hotfix) if minor
- Rollback if critical
- Extend hypercare period

Impact: PRM blocked until stability demonstrated.

If Support Not Ready:

⚠️ Support team not ready for handover

Gaps:
- {list training gaps or readiness issues}

Recommendation: Additional training required
- Schedule supplemental training
- Update runbooks
- Defer handover by {days} days

Impact: Cannot achieve PRM without support acceptance.

Success Criteria

This orchestration succeeds when:

• [ ] Operational Capability Milestone validated (OCM complete)
• [ ] Production environment provisioned and validated
• [ ] Production deployment SUCCESSFUL and STABLE
• [ ] User training COMPLETE and UAT PASSED
• [ ] Support handover ACCEPTED (Support Lead signoff)
• [ ] Operations handover ACCEPTED (Operations Lead signoff)
• [ ] Hypercare period COMPLETED (7-14 days, no critical issues)
• [ ] Product Release Milestone achieved (PRM review passed)

Metrics to Track

During orchestration, track:

• Production stability: Uptime %, incidents, error rate %
• User adoption: Active users, adoption rate %, satisfaction score
• Support effectiveness: Ticket volume, MTTR, escalations
• Business value: Success metrics vs. baseline, ROI forecast
• Deployment success rate: % of deployments without rollback

References

Templates (via $AIWG_ROOT):

• Deployment Plan: templates/deployment/deployment-plan-template.md
• Release Notes: templates/deployment/release-notes-template.md
• Support Runbook: templates/deployment/support-runbook-template.md
• Product Acceptance Plan: templates/deployment/product-acceptance-plan-template.md
• Infrastructure Definition: templates/deployment/infrastructure-definition-template.md

Gate Criteria:

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

Multi-Agent Pattern:

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

Orchestrator Architecture:

• docs/orchestrator-architecture.md

Natural Language Translations:

• docs/simple-language-translations.md