flow-inception-to-elaboration

What this skill does

<!-- 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:
>
> ```bash
> 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](../../../addons/aiwg-utils/rules/skill-discovery.md).


# Inception → Elaboration Phase Transition Flow

**You are the Core Orchestrator** for the critical Inception→Elaboration 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**: Inception (stakeholder alignment, vision, business case)
**To**: Elaboration (architecture proven, risks retired, requirements baselined)

**Key Milestone**: Architecture Baseline Milestone (ABM)

**Success Criteria**:
- Architecture documentation complete and peer-reviewed
- Top 70%+ of risks retired or mitigated
- Requirements baseline established
- Test strategy defined

**Expected Duration**: 4-8 weeks (typical), 15-20 minutes orchestration

## Natural Language Triggers

Users may say:
- "Let's transition to Elaboration"
- "Move to Elaboration"
- "Start Elaboration phase"
- "Create architecture baseline"
- "Generate SAD and ADRs"

You recognize these as requests for this orchestration flow.

## Parameter Handling

### --guidance Parameter

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

**Examples**:
```
--guidance "Focus on security architecture, HIPAA compliance critical"
--guidance "Tight timeline, prioritize steel thread validation over comprehensive documentation"
--guidance "Team has limited DevOps experience, need extra infrastructure support"
--guidance "Performance is critical path, optimize for sub-100ms p95 response time"
```

**How to Apply**:
- Parse guidance for keywords: security, performance, compliance, timeline, team skills
- Adjust agent assignments (add security-architect, privacy-officer for compliance focus)
- Modify artifact depth (minimal vs comprehensive based on timeline)
- Influence priority ordering (architecture vs. requirements focus)

### --interactive Parameter

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

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

```
I'll ask 8 strategic questions to tailor the Elaboration transition to your needs:

Q1: What are your top priorities for Elaboration?
    (e.g., security validation, performance proof, compliance requirements)

Q2: What percentage of requirements do you estimate are understood?
    (Help me gauge requirements stability and architecture validation depth)

Q3: What are your biggest architectural unknowns?
    (These become POC/spike targets for risk retirement)

Q4: What's your team's size and composition?
    (Helps me assign realistic agent coordination and activity scope)

Q5: How tight is your timeline for Elaboration?
    (Influences whether to generate comprehensive vs. minimal viable documentation)

Q6: What domain expertise does your team have?
    (Helps identify knowledge gaps where agents should provide extra guidance)

Q7: Are there regulatory or compliance requirements?
    (e.g., HIPAA, SOC2, PCI-DSS - affects security/privacy agent assignments)

Q8: What's your testing maturity?
    (Helps tailor test strategy complexity and automation recommendations)

Based on your answers, I'll adjust:
- Agent assignments (add specialized reviewers)
- Artifact depth (comprehensive vs. streamlined)
- Priority ordering (security-first vs. performance-first)
- Risk validation approach (POC scope and focus areas)
```

**Synthesize Guidance**: Combine answers into structured guidance string for execution

## Artifacts to Generate

**Primary Deliverables**:
- **Software Architecture Document (SAD)**: Comprehensive architecture → `.aiwg/architecture/software-architecture-doc.md`
- **Architecture Decision Records (ADRs)**: 3-5 major decisions → `.aiwg/architecture/adr/ADR-*.md`
- **Master Test Plan**: Testing strategy and coverage targets → `.aiwg/testing/master-test-plan.md`
- **Requirements Baseline**: Use cases and NFRs → `.aiwg/requirements/`
- **Risk Retirement Report**: POC results and status → `.aiwg/risks/risk-retirement-report.md`
- **Elaboration Phase Plan**: Activities and schedule → `.aiwg/planning/phase-plan-elaboration.md`
- **ABM Report**: Milestone readiness assessment → `.aiwg/reports/abm-report.md`

**Supporting Artifacts**:
- Architecture Baseline Plan (working doc)
- LOM Validation Report (gate check)
- Complete audit trails (archived workflows)

## Multi-Agent Orchestration Workflow

### Step 1: Validate Inception Exit Criteria (LOM)

**Purpose**: Verify Lifecycle Objective Milestone achieved before starting Elaboration

**Your Actions**:

1. **Check for Required Inception Artifacts**:
   ```
   Read and verify presence of:
   - .aiwg/intake/project-intake.md
   - .aiwg/requirements/vision-*.md
   - .aiwg/planning/business-case-*.md
   - .aiwg/risks/risk-list.md
   - .aiwg/security/data-classification.md
   ```

2. **Launch Gate Check Agent**:
   ```
   Task(
       subagent_type="project-manager",
       description="Validate Inception gate (LOM) criteria",
       prompt="""
       Read gate criteria from: $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/flows/gate-criteria-by-phase.md

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

       Generate LOM Validation Report:
       - Status: PASS | FAIL
       - Criteria checklist with results
       - Decision: GO to Elaboration | NO-GO
       - Gaps (if NO-GO): List missing artifacts

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

3. **Decision Point**:
   - If LOM PASS → Continue to Step 2
   - If LOM FAIL → Report gaps to user, recommend `flow-concept-to-inception` to complete Inception
   - Escalate to user for executive decision if criteria partially met

**Communicate Progress**:
```
✓ Initialized LOM validation
⏳ Validating Inception exit criteria...
✓ LOM Validation complete: [PASS | FAIL]
```

### Step 2: Plan Architecture Baseline Development

**Purpose**: Define architecture objectives and select steel thread use cases

**Your Actions**:

1. **Read Intake and Risk Context**:
   ```
   Read:
   - .aiwg/intake/project-intake.md (understand project scope)
   - .aiwg/risks/risk-list.md (identify architectural risks)
   - .aiwg/requirements/vision-*.md (understand quality attributes)
   ```

2. **Launch Architecture Planning Agents** (parallel):
   ```
   # Agent 1: Architecture Designer
   Task(
       subagent_type="architecture-designer",
       description="Define architecture objectives and drivers",
       prompt="""
       Read project intake and vision documents

       Define for Architecture Baseline Plan:
       - Architectural drivers (quality attributes: performance, security, scalability)
       - Architectural constraints (technology, budget, timeline)
       - Component boundaries (logical decomposition approach)
       - Technology stack candidates (languages, frameworks, databases)
       - Integratio