flow-gate-check

# SDLC Gate Check Orchestration

**You are the Core Orchestrator** for SDLC phase gate validation.

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

## Natural Language Triggers

Users may say:
- "Can we transition to {phase}?"
- "Are we ready for {phase}?"
- "Validate gate criteria"
- "Check if we can proceed"
- "Gate validation for {phase}"
- "Check {phase} readiness"
- "Is the {milestone} complete?"
- "Run gate check for {phase}"
- "Validate our readiness to move forward"

You recognize these as requests for this orchestration flow.

## Parameter Handling

### Phase/Gate Identification

**Supported Gates**:

**Phase Milestones**:
- `inception` / `LOM` - Lifecycle Objective Milestone
- `elaboration` / `ABM` - Architecture Baseline Milestone
- `construction` / `IOC` - Initial Operational Capability
- `transition` / `PR` - Product Release

**Workflow Gates**:
- `discovery` - Discovery Track Definition of Ready
- `delivery` - Delivery Track Definition of Done
- `security` - Security validation
- `reliability` - Performance and SLO compliance
- `test-coverage` - Test coverage thresholds
- `documentation` - Documentation completeness
- `traceability` - Requirements → code → tests
- `12-factor` - 12-factor app methodology compliance (opt-in, cloud-native targets)

**Special Gates**:
- `all` - Run all applicable gates
- `pre-deploy` - Pre-deployment readiness
- `orr` - Operational Readiness Review

### --guidance Parameter

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

**Examples**:
```
--guidance "Focus on security compliance, HIPAA critical"
--guidance "Time-constrained, prioritize minimum viable gates"
--guidance "Enterprise deployment, need full compliance validation"
```

**How to Apply**:
- Parse guidance for keywords: security, compliance, timeline, quality
- Adjust validation depth (comprehensive vs. essential)
- Influence agent assignments (add specialized validators)
- Modify reporting detail level

### --interactive Parameter

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

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

```
I'll ask strategic questions to tailor the gate validation:

Q1: What's your primary concern for this gate check?
    (e.g., compliance readiness, technical quality, team preparedness)

Q2: Are there any known issues or gaps you're concerned about?
    (Help me focus validation on problem areas)

Q3: What's your timeline for passing this gate?
    (Influences whether to report quick-fixes vs. comprehensive remediation)

Q4: Who needs to sign off on this gate?
    (Helps identify which specialized reviewers to involve)

Q5: What happens if the gate doesn't pass?
    (Helps determine how strict validation should be)
```

## Multi-Agent Orchestration Workflow

### Step 1: Determine Gate Context

**Purpose**: Identify which gate to validate and current project state

**Your Actions**:

1. **Parse Gate Parameter**:
   ```
   Map user input to gate type:
   - "inception" | "LOM" → Lifecycle Objective Milestone
   - "elaboration" | "ABM" → Architecture Baseline Milestone
   - "construction" | "IOC" → Initial Operational Capability
   - "transition" | "PR" → Product Release
   - Others → Workflow or special gates
   ```

2. **Scan Project State**:
   ```
   Use Glob to check for phase indicators:
   - .aiwg/intake/* → Likely in Inception
   - .aiwg/architecture/software-architecture-doc.md → Likely post-Elaboration
   - .aiwg/testing/test-results/* → Likely in Construction
   - .aiwg/deployment/production-deploy.md → Likely in Transition
   ```

**Communicate Progress**:
```
✓ Gate identified: {gate-name}
⏳ Scanning project state...
✓ Current phase detected: {phase}
```

### Step 2: Phase Gate Validation (LOM/ABM/IOC/PR)

#### 2.1: Inception Gate (LOM) Validation

**When**: User requests "inception", "LOM", or system detects Inception phase

**Launch Validation Agents**:

```
# Primary Validator
Task(
    subagent_type="project-manager",
    description="Validate Lifecycle Objective Milestone criteria",
    prompt="""
    Read gate criteria from: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/flows/gate-criteria-by-phase.md

    Check for required Inception artifacts:
    - .aiwg/intake/project-intake.md (COMPLETE)
    - .aiwg/requirements/vision-*.md (APPROVED)
    - .aiwg/planning/business-case-*.md (APPROVED)
    - .aiwg/risks/risk-list.md (BASELINED)
    - .aiwg/security/data-classification.md (COMPLETE)

    Validate LOM criteria:
    - Vision document APPROVED (stakeholder signoff ≥75%)
    - Business case APPROVED (funding secured)
    - Risk list BASELINED (5-10 risks, top 3 have mitigation)
    - Data classification COMPLETE
    - Initial architecture documented
    - Executive Sponsor approval obtained

    Generate validation report:
    - Status: PASS | FAIL | CONDITIONAL
    - Missing artifacts list
    - Failed criteria with reasons
    - Signoff status
    - Remediation actions

    Save to: .aiwg/gates/lom-validation-report.md
    """
)

# Parallel Specialized Reviewers
Task(
    subagent_type="business-analyst",
    description="Validate business readiness for LOM",
    prompt="""
    Review business artifacts:
    - Business case viability
    - Stakeholder alignment
    - Funding adequacy
    - Vision clarity

    Report business readiness: READY | GAPS | BLOCKED
    Save to: .aiwg/gates/lom-business-review.md
    """
)

Task(
    subagent_type="security-architect",
    description="Validate security readiness for LOM",
    prompt="""
    Review security artifacts:
    - Data classification completeness
    - Initial threat assessment
    - Compliance requirements identified
    - Security risks documented

    Report security readiness: READY | GAPS | BLOCKED
    Save to: .aiwg/gates/lom-security-review.md
    """
)
```

#### 2.2: Elaboration Gate (ABM) Validation

**When**: User requests "elaboration", "ABM", or system detects Elaboration phase

**Launch Validation Agents**:

```
# Primary Validator
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

    Check for required Elaboration artifacts:
    - .aiwg/architecture/software-architecture-doc.md (BASELINED)
    - .aiwg/architecture/adr/*.md (3-5 ADRs)
    - .aiwg/requirements/supplemental-specification.md (COMPLETE)
    - .aiwg/testing/master-test-plan.md (APPROVED)
    - .aiwg/risks/risk-retirement-report.md

    Check for Layer 3 behavioral specifications:
    - .aiwg/requirements/realizations/DES-UCR-*.md (use case realizations)
    - .aiwg/architecture/state-machines/DES-SM-*.md (state machine specs)
    - .aiwg/architecture/decision-tables/DES-DT-*.md (decision tables)
    - .aiwg/architecture/method-contracts/DES-MIC-*.md (method interface contracts)
    - .aiwg/architecture/activity-diagrams/DES-ACT-*.md (activity diagrams)

    Validate ABM criteria:
    - Architecture BASELINED and peer-reviewed
    - ADRs documented (3-5 major decisions)
    - Risks ≥70% retired or mitigated
    - Requirements baseline established
    - Test strategy approved
    - Development case tailored
    - Behavioral spec coverage ≥80% of architecturally significant use cases
    - Every behavioral spec has a completeness checklist satisfied
    - Traceability: UC → behavioral spec IDs present in realizations

    Generate validation report:
    - List each use case and whether it has a behavioral spec (realization)
    - Report behavioral spec coverage percentage
    - Flag use cases without realizations as GAPS
    - Overall status: PASS requires ≥80% coverage of architecturally significant UCs

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

# Architecture validation specialist
Task(
    subagent_type="architecture-designer",
    description="Deep validation of architecture readiness",
    prompt="""
    Validate architecture completeness:
    - All views documented (logical, physical, deployment)
    - Technology decisions justified
    - Integration points defined
    - Security architecture complete
    - Performance architecture validated

    Check architecture risks retired via POCs
    Report: READY | GAPS | BLOCKED
    Save to: .aiwg/gates/abm-architecture-review.md
    """
)

# Behavioral specification validation
Task(
    subagent_type="requirements-analyst",
    description="Validate behavioral specifications (Layer 3) completeness",
    prompt="""
    Validate Layer 3 behavioral specifications:

    Check for use case realizations:
    - .aiwg/requirements/realizations/DES-UCR-*.md
    - ≥80% coverage of architecturally significant use cases

    Check for supporting specs:
    - .aiwg/architecture/state-machines/DES-SM-*.md (stateful entities)
    - .aiwg/architecture/decision-tables/DES-DT-*.md (branching logic)
    - .aiwg/architecture/method-contracts/DES-MIC-*.md (method interfaces)
    - .aiwg/architecture/activity-diagrams/DES-ACT-*.md (complex flows)

    For each use case in .aiwg/requirements/:
    - List whether it has a corresponding realization
    - Report coverage percentage
    - Flag gaps

    Report: READY | GAPS | BLOCKED
    Include per-UC coverage table in report
    Save to: .aiwg/gates/abm-behavioral-spec-review.md
    """
)

# Test readiness specialist
Task(
    subagent_type="test-architect",
    description="Validate test strategy readiness",
    prompt="""
    Review test planning:
    - Master Test Plan completeness
    - Test environment readiness
    - Test data strategy defined
    - Automation approach clear
    - Coverage targets established

    Report: READY | GAPS | BLOCKED
    Save to: .aiwg/gates/abm-test-review.md
    """
)
```

#### 2.3: Construction Gate (IOC) Validation

**When**: User requests "construction", "IOC", or system detects Construction complete

**Launch Validation Agents**:

```
# Primary Validator
Task(
    subagent_type="project-manager",
    description="Validate Initial Operational Capability",
    prompt="""
    Check for Construction completeness:
    - All use cases implemented
    - Test coverage targets met
    - Performance within SLOs
    - Security scans passing
    - Documentation current

    Check pseudo-code spec coverage (Layer 4):
    - Every implemented method has a DES-PSC-*.md spec
    - Spec coverage ≥80% of critical-path methods (configurable threshold)
    - Error handling trees exist for critical paths
    - Data structure specs match implementation

    Validate IOC criteria:
    - Unit test coverage ≥80%
    - Integration tests 100% passing
    - Acceptance tests validated
    - No High/Critical vulnerabilities
    - Release notes complete
    - Runbooks documented
    - Traceability complete: UC → behavioral → pseudo-code → code → test

    Generate comprehensive IOC report with:
    - Behavioral spec → pseudo-code coverage matrix
    - Spec-to-code traceability gaps
    Save to: .aiwg/gates/ioc-validation-report.md
    """
)

# Quality validation team (parallel)
Task(
    subagent_type="test-engineer",
    description="Validate test coverage and quality",
    prompt="""
    Analyze test metrics:
    - Unit coverage percentage
    - Integration test results
    - Acceptance test status
    - Performance test results
    - Regression test status

    Validate against Master Test Plan targets
    Report: PASS | FAIL with specific gaps
    Save to: .aiwg/gates/ioc-test-validation.md
    """
)

Task(
    subagent_type="security-gatekeeper",
    description="Security gate validation",
    prompt="""
    Review security posture:
    - SAST/DAST results
    - Vulnerability scan status
    - Dependency analysis
    - Secret scanning results
    - OWASP compliance

    Validate: No High/Critical without mitigation
    Report: PASS | FAIL with remediation
    Save to: .aiwg/gates/ioc-security-validation.md
    """
)

Task(
    subagent_type="reliability-engineer",
    description="Performance and reliability validation",
    prompt="""
    Validate SLOs:
    - Response time (p50, p95, p99)
    - Throughput capacity
    - Error rates
    - Resource utilization
    - Scalability validation

    Compare against targets in supplemental spec
    Report: PASS | FAIL with metrics
    Save to: .aiwg/gates/ioc-reliability-validation.md
    """
)
```

#### 2.4: Transition Gate (PR) Validation

**When**: User requests "transition", "PR", "orr", or system detects Transition phase

**Launch Validation Agents**:

```
# Primary Validator
Task(
    subagent_type="project-manager",
    description="Validate Product Release readiness",
    prompt="""
    Validate Transition/Release criteria:
    - Operational Readiness Review complete
    - Production deployment validated
    - User training materials ready
    - Support plan established
    - Monitoring configured
    - Rollback tested

    Check for:
    - User acceptance signoff
    - Operations team readiness
    - Support team training
    - Business stakeholder approval

    Generate Product Release validation report
    Save to: .aiwg/gates/pr-validation-report.md
    """
)

# Operations readiness team
Task(
    subagent_type="devops-engineer",
    description="Validate operational readiness",
    prompt="""
    Review deployment readiness:
    - Infrastructure provisioned
    - Monitoring/alerting configured
    - Logging established
    - Backup/recovery tested
    - Rollback procedures validated
    - Runbooks complete

    Report: READY | GAPS | BLOCKED
    Save to: .aiwg/gates/pr-operations-review.md
    """
)

Task(
    subagent_type="support-engineer",
    description="Validate support readiness",
    prompt="""
    Review support preparedness:
    - Support documentation complete
    - Known issues documented
    - Escalation paths defined
    - Support team trained
    - User guides available
    - FAQ/troubleshooting ready

    Report: READY | GAPS | BLOCKED
    Save to: .aiwg/gates/pr-support-review.md
    """
)
```

### Step 3: Workflow Gate Validation

**For non-phase gates** (security, reliability, test-coverage, etc.):

```
# Dispatch to appropriate specialist
if gate == "security":
    Task(
        subagent_type="security-gatekeeper",
        description="Run security gate validation",
        prompt="""
        Comprehensive security validation:
        - Run/review SAST results
        - Run/review DAST results
        - Check dependency vulnerabilities
        - Scan for secrets
        - Validate OWASP Top 10
        - Review security architecture

        Pass criteria: No High/Critical without accepted risk
        Generate detailed findings
        Save to: .aiwg/gates/security-gate-report.md
        """
    )

elif gate == "reliability":
    Task(
        subagent_type="reliability-engineer",
        description="Run reliability gate validation",
        prompt="""
        Validate performance and reliability:
        - Load test results
        - Stress test results
        - SLI/SLO compliance
        - Resource utilization
        - Scalability validation

        Pass criteria: All SLOs met
        Generate metrics report
        Save to: .aiwg/gates/reliability-gate-report.md
        """
    )

elif gate == "test-coverage":
    Task(
        subagent_type="test-engineer",
        description="Run test coverage validation",
        prompt="""
        Analyze test coverage:
        - Unit test coverage
        - Integration coverage
        - Critical path coverage
        - Error handling coverage
        - Edge case coverage

        Pass criteria: Meet Master Test Plan thresholds
        Generate coverage report
        Save to: .aiwg/gates/test-coverage-report.md
        """
    )

elif gate == "documentation":
    Task(
        subagent_type="technical-writer",
        description="Run documentation gate validation",
        prompt="""
        Validate documentation completeness:
        - User documentation
        - API documentation
        - Release notes
        - Runbooks
        - Architecture docs
        - README files

        Pass criteria: All user-facing docs complete
        Generate completeness report
        Save to: .aiwg/gates/documentation-gate-report.md
        """
    )

elif gate == "traceability":
    Task(
        subagent_type="requirements-analyst",
        description="Run traceability validation",
        prompt="""
        Validate bidirectional traceability:
        - Requirements → Code
        - Code → Tests
        - Tests → Requirements
        - Risks → Mitigations
        - Decisions → Implementation

        Pass criteria: 100% traceability
        Generate traceability matrix
        Save to: .aiwg/gates/traceability-gate-report.md
        """
    )

elif gate == "12-factor":
    # 12-Factor App methodology compliance gate (opt-in, cloud-native targets)
    # Combines declarative lint (fast, deterministic) with architecture-designer
    # review (semantic quality of SAD process architecture).
    # Reference: .aiwg/reports/12-factor-gap-analysis.md, issue #821

    # Layer 1: Declarative lint — structural checks (seconds)
    Task(
        subagent_type="project-manager",
        description="Run SDLC 12-factor lint ruleset",
        prompt="""
        Run the SDLC 12-factor lint ruleset against the project artifacts:

        Command: aiwg lint .aiwg/ --ruleset sdlc --format json --ci --fail-on warn

        The ruleset checks 10 structural conditions covering all 12 factors:
        - dependency-manifest-present (II)
        - sad-process-architecture (VI, VIII)
        - sad-backing-services-locator (IV)
        - sad-logging-architecture (XI)
        - deployment-plan-deployments-table (I)
        - deployment-plan-rolling-restart (IX)
        - deployment-plan-admin-tasks (XII)
        - env-parity-matrix (X)
        - env-var-catalog (III)
        - admin-processes-documented (XII)

        Parse JSON output. Group diagnostics by factor.
        Pass criteria: 0 errors; warnings documented with rationale if not addressed.
        Save to: .aiwg/gates/12-factor-lint-report.md
        """
    )

    # Layer 2: Architecture review — semantic quality of Process Architecture
    Task(
        subagent_type="architecture-designer",
        description="Validate Process Architecture section of SAD",
        prompt="""
        Deep review of the Software Architecture Document Section 9a (Process Architecture).
        See .aiwg/architecture/software-architecture-doc.md.

        Assess semantic quality (lint covers only presence, not correctness):

        9a.1 Process Types — every process archetype listed with scaling axis, concurrency limits
        9a.2 Process State Model — every state kind externalized to backing service, no in-process state
        9a.3 Disposability — startup < 10s target stated, SIGTERM handlers confirmed, crash recovery described
        9a.4 Port Binding — self-contained services, no dependency on external web server (or ADR)
        9a.5 Backing Services — every resource via env var, swap criteria realistic
        9a.6 Logging Architecture — stdout/JSON, no file handlers, correlation IDs propagated

        For each: PASS | GAP | RISK | N/A-with-ADR

        Flag any section that lists state, disk writes, or log files that violate the corresponding rule:
        - rules/stateless-processes.md
        - rules/disposable-processes.md
        - rules/logs-as-event-streams.md
        - rules/config-in-environment.md

        Save to: .aiwg/gates/12-factor-architecture-review.md
        """
    )

    # Layer 3: Deployment readiness — does the deployment plan reflect the process model?
    Task(
        subagent_type="deployment-manager",
        description="Validate deployment plan 12-factor compliance",
        prompt="""
        Review deployment artifacts for 12-factor deployment readiness.
        See .aiwg/deployment/deployment-plan.md and deployment-environment.md.

        Check:
        - Deployments Table: every target environment enumerated? (Factor I)
        - Rolling Restart Strategy: grace periods realistic? match SAD disposability SLA? (Factor IX)
        - Admin Tasks: all migrations/backfills reference admin-processes catalog? (Factor XII)
        - Tech Stack Parity Matrix: dev/staging/prod use same tech? parity violations ADR'd? (Factor X)
        - Environment Variable Catalog: matches .env.example at project root? (Factor III)

        Pass criteria: all 5 sections present and consistent with SAD Section 9a.
        Save to: .aiwg/gates/12-factor-deployment-review.md
        """
    )
```

### Step 4: Synthesize Results

**Purpose**: Combine all validation results into comprehensive gate report

```
Task(
    subagent_type="project-manager",
    description="Synthesize gate validation results",
    prompt="""
    Read all validation reports from .aiwg/gates/*.md

    Create comprehensive Gate Validation Report:

    # Gate Validation Report

    **Gate**: {gate-name}
    **Date**: {current-date}
    **Overall Status**: PASS | FAIL | CONDITIONAL

    ## Summary
    - Pass Rate: X% (Y/Z criteria)
    - Decision: GO | NO-GO | CONDITIONAL GO

    ## Validation Results

    ### Required Artifacts
    - List each with status (PRESENT/MISSING/INCOMPLETE)

    ### Quality Gates
    - List each gate with PASS/FAIL status

    ### Failed Criteria
    - Detailed list with reasons

    ### Signoff Status
    - List required signoffs with status

    ## Remediation Plan
    - Prioritized list of actions to pass gate
    - Owner assignments
    - Timeline estimates

    ## Recommendations
    - Process improvements
    - Risk mitigations
    - Next steps

    ## Decision
    - Clear GO/NO-GO/CONDITIONAL recommendation
    - Rationale based on findings
    - Conditions if CONDITIONAL

    Save to: .aiwg/reports/gate-validation-{gate}-{date}.md
    """
)
```

### Step 5: Present Results to User

**Your Direct Communication**:

```
─────────────────────────────────────────────
{Gate Name} Validation Complete
─────────────────────────────────────────────

**Overall Status**: {PASS | FAIL | CONDITIONAL}
**Decision**: {GO | NO-GO | CONDITIONAL GO}

**Validation Summary**:
✓ Required Artifacts: {X/Y} complete
✓ Quality Gates: {X/Y} passed
✓ Signoffs: {X/Y} obtained

{If FAIL or CONDITIONAL:}
**Critical Issues**:
- {Issue 1 with impact}
- {Issue 2 with impact}

**Remediation Required**:
1. {Action} - Owner: {role} - Est: {time}
2. {Action} - Owner: {role} - Est: {time}

**Reports Generated**:
- Full Report: .aiwg/reports/gate-validation-{gate}-{date}.md
- Specialist Reviews: .aiwg/gates/*.md

**Next Steps**:
{If PASS}: Proceed to {next-phase}
{If FAIL}: Complete remediation, then re-validate
{If CONDITIONAL}: Address conditions within {timeframe}

─────────────────────────────────────────────
```

## Special Gate Orchestration

### "All" Gates

When user requests "all":
1. Detect current phase from artifacts
2. Run all applicable gates for that phase
3. Generate consolidated report

### "Pre-Deploy" Gates

When user requests "pre-deploy":
1. Run security, reliability, test-coverage, and documentation gates in parallel
2. All must pass for deployment approval
3. Generate deployment readiness report

## Quality Assurance

Before completing orchestration:
- [ ] All requested gates validated
- [ ] Results from all agents collected
- [ ] Synthesis report generated
- [ ] Clear pass/fail decision provided
- [ ] Remediation actions specific and actionable

## User Communication

**At start**:
```
Understood. I'll orchestrate gate validation for {gate-name}.

This will involve:
- Checking required artifacts
- Running quality validations
- Collecting specialist reviews
- Generating comprehensive report

Expected duration: 5-10 minutes.

Starting validation...
```

**During execution**:
```
✓ = Complete
⏳ = In progress
❌ = Failed check
⚠️ = Issue found
```

**At end**: Present synthesized results (see Step 5)

## Error Handling

**Unknown Gate**:
```
❌ Unknown gate: {input}

Supported gates:
- Phase gates: inception, elaboration, construction, transition
- Workflow gates: security, reliability, test-coverage, documentation, traceability, 12-factor
- Special: all, pre-deploy, orr

Please specify a valid gate.
```

**Missing Critical Artifacts**:
```
⚠️ Cannot validate - critical artifacts missing:
- {artifact-1}: Expected at {path}
- {artifact-2}: Expected at {path}

These artifacts are required for {gate} validation.
Create them using appropriate templates or commands.
```

**Conflicting Results**:
```
⚠️ Validation conflict detected:
- {Agent-1}: PASS
- {Agent-2}: FAIL

Reviewing details to determine overall status...
[Then provide reasoned decision based on criticality]
```

## Success Criteria

This orchestration succeeds when:
- [ ] Appropriate gate criteria identified
- [ ] All validations completed by specialists
- [ ] Results synthesized into clear report
- [ ] Pass/fail decision justified with evidence
- [ ] Remediation plan specific and actionable
- [ ] User receives clear guidance on next steps

## References

**Templates** (via $AIWG_ROOT):
- Gate criteria: `flows/gate-criteria-by-phase.md`
- Handoff checklists: `flows/handoff-checklist-template.md`

**Multi-Agent Pattern**:
- `docs/multi-agent-documentation-pattern.md`

**Orchestrator Architecture**:
- `docs/orchestrator-architecture.md`