flow-hypercare-monitoring

What this skill does

# Hypercare Monitoring Flow

**You are the Core Orchestrator** for the post-deployment hypercare monitoring period.

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

## Hypercare Overview

**Definition**: Hypercare is an elevated support period immediately following production deployment, characterized by heightened monitoring, rapid response, and intensive issue resolution.

**Typical Duration**: 7-14 days (configurable based on release complexity and risk)

**Focus Areas**:
- Production stability and SLO compliance
- Rapid incident identification and response
- User adoption and feedback collection
- Support team enablement
- Smooth transition to business-as-usual operations

**Exit Criteria**:
- Zero P0 (Critical) incidents in last 48 hours
- Zero P1 (High) incidents in last 24 hours
- All SLOs met for 72 consecutive hours
- User adoption metrics trending positive
- Support team ready for standard operations
- Hypercare report complete and approved

**Expected Duration**: 7-14 days (typical), 20-30 minutes orchestration

## Natural Language Triggers

Users may say:
- "Start hypercare"
- "Begin hypercare period"
- "Post-launch monitoring"
- "24/7 support period"
- "Activate hypercare monitoring"
- "Launch post-deployment support"

You recognize these as requests for this orchestration flow.

## Parameter Handling

### Hypercare Duration Parameter

**Purpose**: Specify hypercare period length

**Examples**:
```
/flow-hypercare-monitoring 7 .
/flow-hypercare-monitoring 14 .
```

**Default**: 7 days (low-risk deployments), 14 days (high-risk deployments)

### --guidance Parameter

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

**Examples**:
```
--guidance "Focus on security monitoring, financial transaction integrity critical"
--guidance "Performance is key, sub-200ms p95 response time SLO"
--guidance "First production launch, team needs extra support and documentation"
--guidance "High-traffic deployment, anticipate 100K daily active users"
```

**How to Apply**:
- Parse guidance for keywords: security, performance, compliance, scale, team experience
- Adjust agent assignments (add security-gatekeeper, performance-engineer for specific focuses)
- Modify monitoring depth (lightweight vs comprehensive based on complexity)
- Influence priority ordering (stability vs. adoption 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 hypercare to your needs:

Q1: What are your top priorities for hypercare?
    (e.g., stability validation, user adoption, performance monitoring)

Q2: What's the deployment risk level?
    (Helps determine monitoring intensity and duration)

Q3: What are your critical SLOs?
    (Availability, response time, error rate targets)

Q4: What's your expected user volume?
    (Helps set alert thresholds and capacity monitoring)

Q5: What's your support team's experience level?
    (Influences runbook detail and escalation paths)

Q6: What are your biggest concerns about this deployment?
    (These become focus areas for monitoring and validation)

Q7: Are there regulatory or compliance requirements?
    (e.g., HIPAA, SOC2, PCI-DSS - affects audit logging and security monitoring)

Q8: What's your incident response capability?
    (24/7 on-call? Business hours? Helps plan escalation and response)

Based on your answers, I'll adjust:
- Monitoring intensity (alert thresholds, dashboard focus)
- Agent assignments (add specialized monitoring agents)
- Exit criteria strictness (standard vs. elevated)
- Support team guidance level (detailed runbooks vs. minimal)
```

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

## Artifacts to Generate

**Primary Deliverables**:
- **Hypercare Team Roster**: Roles, on-call rotation, contacts → `.aiwg/deployment/hypercare-team-roster.md`
- **Production Health Dashboard**: Real-time monitoring config → `.aiwg/deployment/production-dashboard-config.md`
- **Alert Escalation Matrix**: Severity definitions and response SLAs → `.aiwg/deployment/alert-escalation-matrix.md`
- **Daily Hypercare Standups**: Status reports (daily) → `.aiwg/deployment/hypercare-standup-{YYYY-MM-DD}.md`
- **Incident Response Logs**: All P0/P1 incidents → `.aiwg/deployment/incidents/incident-{ID}.md`
- **Risk Retirement Report**: Validation evidence → `.aiwg/risks/hypercare-risk-validation.md`
- **Hypercare Exit Report**: Final status and transition plan → `.aiwg/reports/hypercare-exit-report.md`

**Supporting Artifacts**:
- SLO tracking logs (hourly updates)
- User adoption metrics (daily updates)
- Support ticket analysis (daily summary)
- Post-incident reviews (PIRs) for all P0/P1
- Corrective action tracker

## Multi-Agent Orchestration Workflow

### Step 1: Establish Hypercare Team and Schedule

**Purpose**: Create dedicated support structure with clear ownership and 24/7 coverage

**Your Actions**:

1. **Read Deployment Context**:
   ```
   Read:
   - .aiwg/deployment/operational-readiness-review.md (team assignments, contacts)
   - .aiwg/deployment/slo-sli-definition.md (SLO targets, monitoring approach)
   - .aiwg/deployment/incident-response-runbook.md (escalation paths)
   ```

2. **Launch Hypercare Planning Agents** (parallel):
   ```
   # Agent 1: Operations Manager
   Task(
       subagent_type="operations-manager",
       description="Create hypercare team roster and on-call rotation",
       prompt="""
       Read ORR team assignments and contacts

       Create Hypercare Team Roster:

       ## Core Team
       - Hypercare Lead: {name} (overall coordination, daily standups)
       - On-Call Engineers: {rotation-schedule} (24/7 coverage)
       - Reliability Engineer: {name} (SLO monitoring, performance analysis)
       - Support Lead: {name} (user-facing issues, ticket triage)
       - DevOps Engineer: {name} (rapid deployment, rollback authority)

       ## Extended Team
       - Product Owner: {name} (prioritization, user impact)
       - Security Gatekeeper: {name} (security incidents)
       - Component Owners: {list by component}

       Create 24/7 On-Call Rotation ({duration} days):
       - Primary on-call schedule (8-hour shifts or daily rotation)
       - Backup on-call contacts
       - Escalation path (P0/P1/P2/P3 response procedures)

       Schedule Daily Standups:
       - Time: {suggest optimal time}
       - Duration: 30 minutes
       - Attendees: Core team (mandatory), Extended team (optional)

       Save to: .aiwg/deployment/hypercare-team-roster.md
       """
   )

   # Agent 2: Reliability Engineer
   Task(
       subagent_type="reliability-engineer",
       description="Configure production monitoring and alerting",
       prompt="""
       Read SLO/SLI definitions

       Configure Production Health Dashboard:

       ## Key Metrics (Auto-Refresh: 30s)

       **Availability**
       - Current Uptime: {percentage}% (Target: ≥99.9%)
       - Service Health: {GREEN | YELLOW | RED}
       - Failed Health Checks: {count}

       **Performance (Last 5 min)**
       - Response Time (p50/p95/p99): {value}ms
       - Throughput: {requests-per-second} req/s
       - Target: p95 < {SLA}ms

       **Errors (Last 5 min)**
       - Error Rate: {percentage}% (Target: <0.1%)
       - 4xx/5xx Errors: {count}
       - Database Errors: {count}

       **Business Metrics**
       - Active Users (Current): {count}
       - Successful Transactions: {count}
       - Transaction Success Rate