flow-change-control

What this skill does

# Change Control Orchestration Flow

**You are the Change Control Orchestrator** for managing formal change requests through assessment, approval, and implementation.

## Your Role

**You orchestrate multi-agent workflows. You do NOT execute bash scripts.**

When the user requests change control (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 change status

## Change Control Overview

**Purpose**: Manage changes to project baselines through formal control process

**Key Activities**:
- Baseline identification and management
- Change impact assessment across all dimensions
- Change Control Board (CCB) review and approval
- Baseline updates and version control
- Stakeholder communication

**Success Criteria**:
- All changes formally documented
- Impact assessed across scope, schedule, cost, quality, risk
- CCB decision recorded with rationale
- Baselines updated and versioned
- Stakeholders notified appropriately

## Natural Language Triggers

Users may say:
- "Submit change request for {change}"
- "Process change request {id}"
- "Change control for {feature/requirement/architecture}"
- "Review change request"
- "CCB review needed"
- "Assess impact of {change}"
- "Update baseline for {change}"

You recognize these as requests for this orchestration flow.

## Parameter Handling

### Change Types

Recognize and categorize:
- **scope**: Feature additions, requirement changes, functionality modifications
- **schedule**: Deadline shifts, milestone adjustments, timeline changes
- **resource**: Team changes, budget adjustments, tool changes
- **technical**: Architecture changes, technology stack updates, design changes
- **process**: Methodology changes, workflow updates, tool adoption
- **risk**: Risk-driven changes, mitigation implementations, contingency activation

### --guidance Parameter

**Purpose**: User provides context to prioritize change assessment

**Examples**:
```
--guidance "Critical customer requirement, fast-track approval needed"
--guidance "Budget impact analysis critical, cost overrun risk"
--guidance "Security implications, need thorough security review"
--guidance "Breaking change, requires migration strategy"
```

**How to Apply**:
- Parse for urgency indicators (critical, emergency, fast-track)
- Identify focus areas (security, performance, cost, compliance)
- Adjust CCB composition (add specialist reviewers)
- Modify assessment depth (comprehensive vs. streamlined)

### --interactive Parameter

**Purpose**: You ask strategic questions about the change

**Questions to Ask** (if --interactive):
```
I'll ask 6 strategic questions to understand this change request:

Q1: What triggered this change request?
    (e.g., customer request, defect discovery, risk mitigation, opportunity)

Q2: What's the urgency level?
    (Helps determine priority: P0-Critical, P1-High, P2-Medium, P3-Low)

Q3: What's your estimated impact scope?
    (Small: 1-2 components, Medium: 3-5 components, Large: system-wide)

Q4: Are there any compliance or regulatory implications?
    (Affects review requirements and approval chain)

Q5: What's your rollback confidence if this change fails?
    (High: easy rollback, Medium: some risk, Low: difficult to reverse)

Q6: What's your change control maturity?
    (Ad-hoc, Defined process, Mature CCB, Automated workflows)

Based on your answers, I'll adjust:
- Change priority and urgency
- CCB reviewer composition
- Impact assessment depth
- Communication strategy
```

## Artifacts to Generate

**Primary Deliverables**:
- **Change Request**: Formal request documentation → `.aiwg/decisions/change-requests/CR-{id}.md`
- **Impact Assessment**: Multi-dimensional analysis → `.aiwg/decisions/impact-assessments/IA-{id}.md`
- **CCB Decision Record**: Meeting notes and decision → `.aiwg/decisions/ccb-meetings/CCB-{date}.md`
- **Baseline Update Log**: Version control records → `.aiwg/decisions/baseline-updates/BU-{id}.md`
- **Stakeholder Notification**: Communication records → `.aiwg/decisions/communications/COMM-{id}.md`
- **Change Implementation Tracking**: Work items and status → `.aiwg/decisions/implementation/IMPL-{id}.md`

## Multi-Agent Orchestration Workflow

### Step 1: Document Change Request

**Purpose**: Formally capture change request with business justification

**Your Actions**:

1. **Initialize Change Request**:
   ```
   # Generate change ID if not provided
   If no change-id provided:
     change-id = "CR-$(date +%Y%m%d)-{sequential}"

   Create directories:
   - .aiwg/decisions/change-requests/
   - .aiwg/decisions/impact-assessments/
   - .aiwg/decisions/ccb-meetings/
   ```

2. **Launch Change Documentation Agent**:
   ```
   Task(
       subagent_type="requirements-analyst",
       description="Document formal change request",
       prompt="""
       Create change request for: {change-description}
       Change Type: {scope|schedule|resource|technical|process|risk}

       Document using template from $AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/management/change-request-template.md:

       1. Change Request Summary
          - Change ID: {change-id}
          - Requestor: {name/role}
          - Date Submitted: {current-date}
          - Change Type: {type}
          - Priority: {P0|P1|P2|P3} (based on urgency)

       2. Business Justification
          - Why is this change needed?
          - What problem does it solve or opportunity does it capture?
          - What happens if we don't make this change?

       3. Current State
          - Describe the system/process as it exists today
          - Identify specific artifacts affected
          - Document current baseline version

       4. Desired State
          - Describe the system/process after the change
          - Define success criteria
          - Specify acceptance criteria

       5. Proposed Approach
          - High-level implementation strategy
          - Alternative approaches considered
          - Recommended approach with rationale

       Save to: .aiwg/decisions/change-requests/CR-{id}.md
       """
   )
   ```

**Communicate Progress**:
```
✓ Change request initialized: CR-{id}
⏳ Documenting change request...
✓ Change request documented: .aiwg/decisions/change-requests/CR-{id}.md
```

### Step 2: Conduct Impact Assessment

**Purpose**: Analyze change impact across all project dimensions

**Your Actions**:

1. **Read Project Context**:
   ```
   Read key artifacts:
   - .aiwg/architecture/software-architecture-doc.md (if exists)
   - .aiwg/planning/project-plan.md (if exists)
   - .aiwg/risks/risk-list.md
   - .aiwg/requirements/*.md (affected requirements)
   ```

2. **Launch Parallel Impact Assessment Agents**:
   ```
   # Agent 1: Scope and Requirements Impact
   Task(
       subagent_type="requirements-analyst",
       description="Assess scope and requirements impact",
       prompt="""
       Analyze change request: .aiwg/decisions/change-requests/CR-{id}.md

       Assess Scope Impact:
       - Which requirements are affected? (list requirement IDs)
       - Which features are impacted? (list features)
       - Does this change project vision or objectives?
       - What's the ripple effect on dependent features?

       Categorize impact:
       - Low: Minor change to existing feature (<5% scope)
       - Medium: New feature or significant change (5-15% scope)
       - High: Changes to core functionality (>15% scope)

       Document findings in impact assessment format.
       Save to: .aiwg/working/change-control/scope-impact-{id}.md
       """
   )

   # Agent 2: Schedule and Cost Impact
   Task(
       subagent_type="project-manager",
       description="Assess schedule and cost impact",
       prompt="""
       Analyze cha