@luanpdd/kit-mcp 1.19.0 → 1.21.0

package/kit/commands/burn-rate-status.md

@@ -1,7 +1,7 @@
 ---
 name: burn-rate-status
-description: Tabela de burn rate por SLO consumindo .planning/slos/*.yml + .planning/metrics/snapshots/. Calcula SLI atual, burn rate (% budget gasto/h), ETA exhaustão e ação (PAGE/TICKET/WARN/OK). Aplica skill burn-rate-alerting.
-argument-hint: "[<slo_name>] [--lookahead 4h] [--baseline 1h] [--format table|json]"
+description: Tabela de burn rate dual-window por SLO consumindo .planning/slos/*.yml + .planning/metrics/snapshots/. Calcula SLI atual, fast_burn (1h) + slow_burn (6h) independentes, ETA exhaustão e ação combinada (PAGE/TICKET/WARN/OK). Aplica skill burn-rate-alerting (fator 4× lookahead/baseline canônico Google SRE).
+argument-hint: "[<slo_name>] [--fast-baseline 1h] [--slow-baseline 6h] [--format table|json]"
 allowed-tools:
   - Read
   - Bash
@@ -9,32 +9,32 @@ allowed-tools:
 ---
 
 <objective>
-Snapshot de burn rate para 1 SLO (se especificado) ou TODOS os SLOs definidos em `.planning/slos/*.yml`. Aplica skill [`burn-rate-alerting`](../skills/burn-rate-alerting/SKILL.md) — fórmula `burn_rate = error_rate / (1 - target)`, lookahead ≤ 4× baseline.
+Snapshot de burn rate **dual-window** (1h fast + 6h slow) para 1 SLO (se especificado) ou TODOS os SLOs definidos em `.planning/slos/*.yml`. Aplica skill [`burn-rate-alerting`](../skills/burn-rate-alerting/SKILL.md) — fórmula canônica `burn_rate = error_rate / (1 - target)`, com lookahead/baseline obedecendo o **fator 4×** (page-tier: lookahead 1h ≤ 4× baseline 5m equivalente operacional; ticket-tier: lookahead 6h ≤ 4× baseline 30m). Status combinado segue o canonical Google SRE: PAGE quando ambas as janelas críticas, TICKET quando apenas slow erosion sustained, WARN para spike-only ou mild burn, OK quando ambas as janelas em estado saudável.
 
-**Lê:** `.planning/slos/*.yml` (definição) + `.planning/metrics/snapshots/*.json` (eventos persistidos via `metrics.persistSnapshot()` — Phase 99).
+**Lê:** `.planning/slos/*.yml` (definição com `alert_thresholds.page` + `.ticket`) + `.planning/metrics/snapshots/*.json` (eventos persistidos via `metrics.persistSnapshot()` — Phase 99 + Phase 102 auto-snapshot).
 
 **Cria/Atualiza:** nada — comando read-only.
 
-**Após:** o user vê tabela com status (PAGE / TICKET / WARN / OK) e pode escolher invocar `/investigar-producao` se há burn ativo, ou rodar mais carga e re-snapshotar via `metrics-snapshot` MCP tool se a janela está vazia.
+**Após:** o user vê tabela com colunas `fast_burn`, `slow_burn`, `combined` (status PAGE / TICKET / WARN / OK) e pode escolher invocar `/investigar-producao` se há burn ativo, ou aguardar mais snapshots se ambas janelas estão `no_data`.
 </objective>
 
 <context>
 **Argumentos:** `$ARGUMENTS` — opcional `<slo_name>` para 1 SLO; sem args = todos.
 
-**Flags:**
-- `--lookahead <duration>` — janela predictive (default: `4h` para short-term page-tier)
-- `--baseline <duration>` — janela base (default: `1h`)
-- `--format <table|json>` — output format (default: `table`)
+**Flags (defaults dual-window — Phase 103):**
+- `--fast-baseline <duration>` — janela fast (page-tier). Default: `1h`.
+- `--slow-baseline <duration>` — janela slow (ticket-tier). Default: `6h`.
+- `--format <table|json>` — output format. Default: `table`.
 
-**Combinações canônicas:**
-- short-term (page-tier): lookahead 4h, baseline 1h
-- long-term (ticket-tier): lookahead 3d, baseline 18h
+**Combinações canônicas (skill burn-rate-alerting):**
+- **Fast (page-tier):** lookahead 1h, baseline 5m, multiplier 14.4× — esgota ~2% do budget mensal em 1h.
+- **Slow (ticket-tier):** lookahead 6h, baseline 30m, multiplier 6× — esgota ~10% do budget mensal em 6h.
 
-**Phase 99 wiring:** este comando consome dados persistidos pela API
-`persistSnapshot()` adicionada em `src/core/metrics.js` (Phase 99). Sem
-snapshots na janela, o comando emite "no_data" para o SLO em vez de
-inventar números. Para gerar dados, invoque o MCP tool `metrics-snapshot`
-durante uso normal — futura fase pode auto-persistir.
+**Fator 4×:** lookahead ≤ 4× baseline para extrapolação confiável (skill rule). 1h ≤ 4× 15m e 6h ≤ 4× 90m são ambos respeitados; defaults operacionais são page (1h baseline) + ticket (6h baseline) — a janela `lookahead` propriamente dita está embutida nos `alert_thresholds.{page,ticket}.lookahead` do YAML do SLO.
+
+**Phase 99 + 102 wiring:** este comando consome dados persistidos automaticamente pelo handler MCP `metrics-snapshot` (Phase 102 OBS-20-01 — auto-persist via `persistSnapshot()` em cada call com throttle 1s). Sem snapshots na janela, o comando emite "no_data" para o SLO em vez de inventar números.
+
+**Cross-reference:** este comando é a implementação do pattern "dashboard de burn rate" canônico documentado em [`kit/skills/burn-rate-alerting/SKILL.md`](../skills/burn-rate-alerting/SKILL.md). A skill é a SSOT da fórmula e dos thresholds; este comando é o renderer.
 </context>
 
 <process>
@@ -44,12 +44,12 @@ durante uso normal — futura fase pode auto-persistir.
 Bash:
 ```bash
 SLO_NAME=$(echo "$ARGUMENTS" | awk '{for(i=1;i<=NF;i++) if($i !~ /^--/) {print $i; exit}}')
-LOOKAHEAD=$(echo "$ARGUMENTS" | grep -oE -- '--lookahead [^ ]+' | awk '{print $2}')
-BASELINE=$(echo "$ARGUMENTS" | grep -oE -- '--baseline [^ ]+' | awk '{print $2}')
+FAST_BASELINE=$(echo "$ARGUMENTS" | grep -oE -- '--fast-baseline [^ ]+' | awk '{print $2}')
+SLOW_BASELINE=$(echo "$ARGUMENTS" | grep -oE -- '--slow-baseline [^ ]+' | awk '{print $2}')
 FORMAT=$(echo "$ARGUMENTS" | grep -oE -- '--format [^ ]+' | awk '{print $2}')
 
-[ -z "$LOOKAHEAD" ] && LOOKAHEAD="4h"
-[ -z "$BASELINE" ] && BASELINE="1h"
+[ -z "$FAST_BASELINE" ] && FAST_BASELINE="1h"
+[ -z "$SLOW_BASELINE" ] && SLOW_BASELINE="6h"
 [ -z "$FORMAT" ] && FORMAT="table"
 ```
 
@@ -65,8 +65,8 @@ to_ms() {
     *) echo 0 ;;
   esac
 }
-LOOKAHEAD_MS=$(to_ms "$LOOKAHEAD")
-BASELINE_MS=$(to_ms "$BASELINE")
+FAST_BASELINE_MS=$(to_ms "$FAST_BASELINE")
+SLOW_BASELINE_MS=$(to_ms "$SLOW_BASELINE")
 ```
 
 ## 2. Listar SLOs (FIX Phase 99: extension `.yml`, não `.md`)
@@ -90,7 +90,7 @@ if [ ${#EXISTING_SLOS[@]} -eq 0 ]; then
 fi
 ```
 
-## 3. Para cada SLO, carregar metadata + calcular SLI
+## 3. Para cada SLO, carregar metadata + calcular SLI dual-window
 
 Para cada `SLO_FILE` em `EXISTING_SLOS`:
 
@@ -110,145 +110,257 @@ TARGET_MS=$(grep -oE '^target_ms:\s*[0-9]+' "$SLO_FILE" | awk '{print $2}')
 PERCENTILE=$(grep -oE '^\s+percentile:\s*[0-9]+' "$SLO_FILE" | awk '{print $2}')
 ```
 
-### 3.2 Carregar snapshots da janela baseline
+### 3.2 Extrair `alert_thresholds.page` (fast) + `.ticket` (slow) do YAML
+
+Phase 103 (OBS-20-02) — leitura dos dois blocos via awk com state machine. Cada bloco tem `lookahead`, `baseline`, `burn_rate_multiplier`. Defaults canônicos aplicados se ausentes (defensive default — ver fallback abaixo).
+
+```bash
+# alert_thresholds.page (fast / page-tier)
+FAST_LOOKAHEAD=$(awk '/^\s*alert_thresholds:/,/^[a-zA-Z]/{if(/^\s*page:/){p=1;next}else if(p && /^\s+lookahead:/){print $2;exit}else if(p && /^\s*ticket:/){exit}}' "$SLO_FILE")
+FAST_BASELINE_YAML=$(awk '/^\s*alert_thresholds:/,/^[a-zA-Z]/{if(/^\s*page:/){p=1;next}else if(p && /^\s+baseline:/){print $2;exit}else if(p && /^\s*ticket:/){exit}}' "$SLO_FILE")
+FAST_MULTIPLIER=$(awk '/^\s*alert_thresholds:/,/^[a-zA-Z]/{if(/^\s*page:/){p=1;next}else if(p && /^\s+burn_rate_multiplier:/){print $2;exit}else if(p && /^\s*ticket:/){exit}}' "$SLO_FILE")
+
+# alert_thresholds.ticket (slow / ticket-tier)
+SLOW_LOOKAHEAD=$(awk '/^\s*alert_thresholds:/,/^[a-zA-Z]/{if(/^\s*ticket:/){t=1;next}else if(t && /^\s+lookahead:/){print $2;exit}}' "$SLO_FILE")
+SLOW_BASELINE_YAML=$(awk '/^\s*alert_thresholds:/,/^[a-zA-Z]/{if(/^\s*ticket:/){t=1;next}else if(t && /^\s+baseline:/){print $2;exit}}' "$SLO_FILE")
+SLOW_MULTIPLIER=$(awk '/^\s*alert_thresholds:/,/^[a-zA-Z]/{if(/^\s*ticket:/){t=1;next}else if(t && /^\s+burn_rate_multiplier:/){print $2;exit}}' "$SLO_FILE")
+
+# Defensive defaults — fator 4× canonical Google SRE values.
+# Se um SLO YAML antigo / parcial não declarar alert_thresholds, aplicamos
+# os defaults da skill burn-rate-alerting verbatim:
+#   page: 14.4× / lookahead 1h / baseline 5m
+#   ticket: 6× / lookahead 6h / baseline 30m
+[ -z "$FAST_MULTIPLIER" ] && FAST_MULTIPLIER="14.4"
+[ -z "$SLOW_MULTIPLIER" ] && SLOW_MULTIPLIER="6"
+[ -z "$FAST_LOOKAHEAD" ] && FAST_LOOKAHEAD="1h"
+[ -z "$SLOW_LOOKAHEAD" ] && SLOW_LOOKAHEAD="6h"
+```
+
+### 3.3 Carregar snapshots para AMBAS as janelas
 
-Use a API `loadSnapshots()` adicionada em Phase 99. Inline node script:
+Use a API `loadSnapshots()` (Phase 99) com duas chamadas — uma para fast (1h), uma para slow (6h). Inline node script:
 
 ```bash
-SNAPS_JSON=$(node --input-type=module -e "
+DUAL_SNAPS=$(node --input-type=module -e "
 import { loadSnapshots } from './src/core/metrics.js';
-const snaps = await loadSnapshots(process.cwd(), $BASELINE_MS);
-console.log(JSON.stringify(snaps));
+const fast = await loadSnapshots(process.cwd(), $FAST_BASELINE_MS);
+const slow = await loadSnapshots(process.cwd(), $SLOW_BASELINE_MS);
+console.log(JSON.stringify({fast, slow, fastCount: fast.length, slowCount: slow.length}));
 ")
-SNAPSHOT_COUNT=$(echo "$SNAPS_JSON" | node -e "console.log(JSON.parse(require('fs').readFileSync(0,'utf8')).length)")
+FAST_COUNT=$(echo "$DUAL_SNAPS" | node -e "console.log(JSON.parse(require('fs').readFileSync(0,'utf8')).fastCount)")
+SLOW_COUNT=$(echo "$DUAL_SNAPS" | node -e "console.log(JSON.parse(require('fs').readFileSync(0,'utf8')).slowCount)")
 ```
 
-Se `SNAPSHOT_COUNT < 2`, marcar SLO como `no_data`:
+**no_data conservative semantics:** se EITHER janela tem < 2 snapshots (availability) ou < 1 (latency), o `combined_status` final é `no_data` — preferimos não inventar números a falsamente reportar OK. Isso preserva o contrato "graceful no_data" da Phase 99.
+
 ```bash
-if [ "$SNAPSHOT_COUNT" -lt 2 ]; then
-  echo "SLO $SLO_NAME: insufficient snapshots in baseline window ($BASELINE) — got $SNAPSHOT_COUNT, need ≥2"
-  echo "Generate data: invoke 'metrics-snapshot' MCP tool during normal use."
-  STATUS="no_data"
-  continue  # pula para o próximo SLO
+# A regra exata é aplicada dentro do node script de combinação (3.5),
+# mas o early-out aqui evita trabalho desnecessário no caso comum.
+if [ "$FAST_COUNT" -lt 2 ] && [ "$SLOW_COUNT" -lt 2 ]; then
+  echo "SLO $SLO_NAME: insufficient snapshots in BOTH windows (fast=$FAST_COUNT, slow=$SLOW_COUNT)"
+  echo "Generate data: invocações ao MCP tool 'metrics-snapshot' agora auto-persistem (Phase 102 OBS-20-01)."
+  COMBINED_STATUS="no_data"
+  continue
 fi
 ```
 
-### 3.3 Calcular SLI por tipo de SLO
+### 3.4 Calcular SLI por tipo de SLO (fast E slow independentes)
 
 **Availability (`type: event-based`):**
 
-Inline node — primeiro vs último snapshot dentro da janela. Delta de counters dá good/bad events na janela:
+Inline node — primeiro vs último snapshot **dentro de cada janela**. Delta de counters dá good/bad events:
 
 ```bash
-SLI_RESULT=$(node --input-type=module -e "
+DUAL_SLI=$(node --input-type=module -e "
 import { loadSnapshots } from './src/core/metrics.js';
-const snaps = await loadSnapshots(process.cwd(), $BASELINE_MS);
-if (snaps.length < 2) { console.log(JSON.stringify({sli:null, error:'no_data'})); process.exit(0); }
-const first = snaps[0];
-const last = snaps[snaps.length - 1];
-let goodFirst = 0, goodLast = 0, totalFirst = 0, totalLast = 0;
-for (const [k,v] of Object.entries(first.counters)) {
-  if (k.endsWith(':ok')) goodFirst += v;
-  totalFirst += v;
+const fastSnaps = await loadSnapshots(process.cwd(), $FAST_BASELINE_MS);
+const slowSnaps = await loadSnapshots(process.cwd(), $SLOW_BASELINE_MS);
+
+function sliFromSnaps(snaps) {
+  if (snaps.length < 2) return {sli: null, errorRate: 0, good: 0, total: 0, error: 'no_data'};
+  const first = snaps[0];
+  const last = snaps[snaps.length - 1];
+  let goodFirst = 0, goodLast = 0, totalFirst = 0, totalLast = 0;
+  for (const [k,v] of Object.entries(first.counters)) {
+    if (k.endsWith(':ok')) goodFirst += v;
+    totalFirst += v;
+  }
+  for (const [k,v] of Object.entries(last.counters)) {
+    if (k.endsWith(':ok')) goodLast += v;
+    totalLast += v;
+  }
+  const good = goodLast - goodFirst;
+  const total = totalLast - totalFirst;
+  const sli = total > 0 ? good / total : null;
+  const errorRate = total > 0 ? (total - good) / total : 0;
+  return {sli, errorRate, good, total};
 }
-for (const [k,v] of Object.entries(last.counters)) {
-  if (k.endsWith(':ok')) goodLast += v;
-  totalLast += v;
-}
-const good = goodLast - goodFirst;
-const total = totalLast - totalFirst;
-const sli = total > 0 ? good / total : null;
-const errorRate = total > 0 ? (total - good) / total : 0;
-console.log(JSON.stringify({sli, errorRate, good, total, totalFirst, totalLast}));
+
+const fastSli = sliFromSnaps(fastSnaps);
+const slowSli = sliFromSnaps(slowSnaps);
+console.log(JSON.stringify({fast: fastSli, slow: slowSli}));
 ")
 ```
 
 **Latency (`type: percentile`):**
 
-Para latency, usar o p95 do último snapshot na janela (cumulative — FIFO histogram dá p95 sobre as últimas 1000 amostras). SLI = fração de samples acima de target_ms é o budget consumido.
+Para latency, p95 do último snapshot em CADA janela. SLI = fração de samples NOT acima de target_ms.
 
 ```bash
-SLI_RESULT=$(node --input-type=module -e "
+DUAL_SLI=$(node --input-type=module -e "
 import { loadSnapshots } from './src/core/metrics.js';
-const snaps = await loadSnapshots(process.cwd(), $BASELINE_MS);
-if (snaps.length < 1) { console.log(JSON.stringify({sli:null, error:'no_data'})); process.exit(0); }
-const last = snaps[snaps.length - 1];
 const target = $TARGET_MS;
-let totalSamples = 0, slowSamples = 0;
-for (const [tool, lat] of Object.entries(last.latency)) {
-  totalSamples += lat.count;
-  if (lat.p95 > target) slowSamples += Math.round(lat.count * 0.05); // approximation: p95 above target → ~5% slow
+const fastSnaps = await loadSnapshots(process.cwd(), $FAST_BASELINE_MS);
+const slowSnaps = await loadSnapshots(process.cwd(), $SLOW_BASELINE_MS);
+
+function latencySli(snaps) {
+  if (snaps.length < 1) return {sli: null, errorRate: 0, totalSamples: 0, slowSamples: 0, error: 'no_data'};
+  const last = snaps[snaps.length - 1];
+  let totalSamples = 0, slowSamples = 0;
+  for (const lat of Object.values(last.latency)) {
+    totalSamples += lat.count;
+    if (lat.p95 > target) slowSamples += Math.round(lat.count * 0.05);
+  }
+  const sli = totalSamples > 0 ? 1 - (slowSamples / totalSamples) : null;
+  const errorRate = totalSamples > 0 ? slowSamples / totalSamples : 0;
+  return {sli, errorRate, totalSamples, slowSamples};
 }
-const sli = totalSamples > 0 ? 1 - (slowSamples / totalSamples) : null;
-const errorRate = totalSamples > 0 ? slowSamples / totalSamples : 0;
-console.log(JSON.stringify({sli, errorRate, totalSamples, slowSamples, p95Max: Math.max(0, ...Object.values(last.latency).map(l => l.p95 || 0))}));
+
+console.log(JSON.stringify({fast: latencySli(fastSnaps), slow: latencySli(slowSnaps)}));
 ")
 ```
 
-### 3.4 Calcular burn rate + status
+### 3.5 Calcular burn rate + status COMBINADO (dual-window)
 
-Aplicar fórmula canônica da skill `burn-rate-alerting`:
+Aplicar fórmula canônica + status enum dual-window (skill `burn-rate-alerting` — fator 4× canonical):
 
 ```bash
-BURN_STATUS=$(node --input-type=module -e "
-const result = $SLI_RESULT;
-if (result.error) { console.log(JSON.stringify({status:'no_data'})); process.exit(0); }
+DUAL_STATUS=$(node --input-type=module -e "
+const dual = $DUAL_SLI;
 const target = $TARGET_RATIO || (1 - 0.05); // latency: 1 - ratio_above_target (5%)
-const errorRate = result.errorRate;
-const slack = 1 - target;  // budget = (1 - target)
-const burnRate = slack > 0 ? errorRate / slack : 0;
-
-let status, action;
-if (burnRate >= 14.4) {
-  status = 'PAGE';
-  action = 'Page on-call — invoke /investigar-producao';
-} else if (burnRate >= 6.0) {
-  status = 'TICKET';
-  action = 'Open ticket — investigate before budget exhausted';
-} else if (burnRate >= 1.0) {
-  status = 'WARN';
-  action = 'Monitor — burn rate sustained ≥1× exhausts budget in window';
-} else {
-  status = 'OK';
-  action = '—';
+const fastMult = $FAST_MULTIPLIER;
+const slowMult = $SLOW_MULTIPLIER;
+
+function burnFromSli(sli, target) {
+  if (sli.error) return {burnRate: null, error: sli.error};
+  const slack = 1 - target;
+  const burnRate = slack > 0 ? sli.errorRate / slack : 0;
+  return {burnRate, errorRate: sli.errorRate};
+}
+
+// Combined status — canonical dual-window logic per skill burn-rate-alerting (fator 4×):
+//   PAGE   = ambos críticos (fast ≥ 14.4 E slow ≥ 6) → page on-call AGORA
+//   TICKET = slow erosion sustained (slow ≥ 6, fast OK) → ticket de investigação
+//   WARN   = fast spike isolado (fast ≥ 14.4 sozinho) — monitor, NÃO page (alarm flap risk)
+//   WARN   = mild burn em qualquer janela (≥ 1.0×) — sustained drains budget no horizonte
+//   OK     = ambos < 1.0× — saudável
+//   no_data = qualquer janela com snapshots insuficientes (conservative)
+function combinedStatus(fastBurn, fastMult, slowBurn, slowMult) {
+  if (fastBurn === null || slowBurn === null) return 'no_data';
+  const fastTriggered = fastBurn >= fastMult;
+  const slowTriggered = slowBurn >= slowMult;
+  if (fastTriggered && slowTriggered) return 'PAGE';
+  if (slowTriggered) return 'TICKET';
+  if (fastTriggered) return 'WARN';
+  if (fastBurn >= 1.0 || slowBurn >= 1.0) return 'WARN';
+  return 'OK';
+}
+
+const fastBurn = burnFromSli(dual.fast, target);
+const slowBurn = burnFromSli(dual.slow, target);
+const combined = combinedStatus(fastBurn.burnRate, fastMult, slowBurn.burnRate, slowMult);
+
+let action;
+switch (combined) {
+  case 'PAGE':
+    action = 'Page on-call NOW — invoke /investigar-producao';
+    break;
+  case 'TICKET':
+    action = 'Open ticket — slow erosion sustained, investigate before budget exhausted';
+    break;
+  case 'WARN':
+    action = 'Monitor — burn rate ≥1× either window, sustained drains budget';
+    break;
+  case 'no_data':
+    action = '— (await more snapshots; auto-persist via metrics-snapshot tool — Phase 102)';
+    break;
+  default:
+    action = '—';
 }
 
-// ETA exhaustion (predictive). For burn_rate=0 (no errors), ETA is ∞.
-const baselineHours = $BASELINE_MS / 3600000;
-const eta = burnRate > 0 ? (1 / burnRate) * 30 * 24 / baselineHours : null; // hours until exhausted
+// ETA exhaustion (predictive). Use slow window (more stable signal for budget extrapolation).
+// For burn=0 (no errors), ETA is ∞.
+const slowBurnRate = slowBurn.burnRate;
+const baselineHours = $SLOW_BASELINE_MS / 3600000;
+const eta = (slowBurnRate !== null && slowBurnRate > 0)
+  ? (1 / slowBurnRate) * 30 * 24 / baselineHours
+  : null;
 const etaStr = eta === null ? '—' : (eta < 24 ? eta.toFixed(1) + 'h' : (eta/24).toFixed(1) + 'd');
 
-console.log(JSON.stringify({status, action, burnRate: burnRate.toFixed(2), errorRate: (errorRate*100).toFixed(2), eta: etaStr}));
+const fastBurnFmt = fastBurn.burnRate === null ? '—' : fastBurn.burnRate.toFixed(2) + '×';
+const slowBurnFmt = slowBurn.burnRate === null ? '—' : slowBurn.burnRate.toFixed(2) + '×';
+
+// fast_status / slow_status são derivados em isolation (informativo na tabela);
+// combined_status é o veredito operacional.
+function singleStatus(burn, mult) {
+  if (burn === null) return 'no_data';
+  if (burn >= mult) return mult === parseFloat('$FAST_MULTIPLIER') ? 'PAGE-FAST' : 'TICKET-SLOW';
+  if (burn >= 1.0) return 'WARN';
+  return 'OK';
+}
+const fastStatus = singleStatus(fastBurn.burnRate, fastMult);
+const slowStatus = singleStatus(slowBurn.burnRate, slowMult);
+
+console.log(JSON.stringify({
+  fast_burn: fastBurnFmt,
+  slow_burn: slowBurnFmt,
+  fast_status: fastStatus,
+  slow_status: slowStatus,
+  combined_status: combined,
+  action: action,
+  eta: etaStr,
+}));
 ")
 ```
 
-### 3.5 Acumular linha da tabela
+### 3.6 Acumular linha da tabela (colunas dual-window)
 
 ```bash
-SLO_ROWS+=("| $SLO_NAME | ${TARGET_RATIO:-${TARGET_MS}ms p$PERCENTILE} | $BASELINE | ${ERROR_RATE}% | ${BURN_RATE}× | $ETA | **$STATUS** | $ACTION |")
+SLO_ROWS+=("| $SLO_NAME | ${TARGET_RATIO:-${TARGET_MS}ms p$PERCENTILE} | ${FAST_BURN} | ${SLOW_BURN} | **${COMBINED_STATUS}** | $ETA | $ACTION |")
 ```
 
-## 4. Renderizar tabela mestra
+## 4. Renderizar tabela mestra (Phase 103 dual-window)
 
 ```text
 ═══════════════════════════════════════════════════════════
- framework ► BURN-RATE-STATUS ▸ {timestamp}
- baseline=$BASELINE  lookahead=$LOOKAHEAD  snapshots=$TOTAL_SNAPS
+ framework ▸ BURN-RATE-STATUS (dual-window) ▸ {timestamp}
+ fast_baseline=$FAST_BASELINE  slow_baseline=$SLOW_BASELINE
+ fast_multiplier=$FAST_MULTIPLIER (page)  slow_multiplier=$SLOW_MULTIPLIER (ticket)
+ snapshots fast=$FAST_COUNT  slow=$SLOW_COUNT
 ═══════════════════════════════════════════════════════════
 
-| SLO | Target | Window | Error rate | Burn rate | ETA exhaustão | Status | Ação |
-|---|---|---|---|---|---|---|---|
+| SLO | Target | Fast (1h) | Slow (6h) | Combined | ETA exhaustão | Ação |
+|---|---|---|---|---|---|---|
 {$SLO_ROWS}
 ```
 
+**Exemplo concreto:**
+
+```markdown
+| SLO | Target | Fast (1h) | Slow (6h) | Combined | ETA exhaustão | Ação |
+|---|---|---|---|---|---|---|
+| mcp-tool-availability | 99.5% | 0.42× OK | 0.18× OK | **OK** | — | — |
+| mcp-tool-latency | 200ms p95 | 16.0× PAGE-FAST | 8.5× TICKET-SLOW | **PAGE** | 4.2h | Page on-call NOW — invoke /investigar-producao |
+```
+
 ## 5. Sugerir próximas ações
 
 ```bash
 # Contar status counts
-PAGE_COUNT=$(echo "$SLO_ROWS" | grep -c "PAGE" || echo 0)
-TICKET_COUNT=$(echo "$SLO_ROWS" | grep -c "TICKET" || echo 0)
-WARN_COUNT=$(echo "$SLO_ROWS" | grep -c "WARN" || echo 0)
-NO_DATA_COUNT=$(echo "$SLO_ROWS" | grep -c "no_data" || echo 0)
+PAGE_COUNT=$(echo "$SLO_ROWS" | grep -c "\*\*PAGE\*\*" || echo 0)
+TICKET_COUNT=$(echo "$SLO_ROWS" | grep -c "\*\*TICKET\*\*" || echo 0)
+WARN_COUNT=$(echo "$SLO_ROWS" | grep -c "\*\*WARN\*\*" || echo 0)
+NO_DATA_COUNT=$(echo "$SLO_ROWS" | grep -c "\*\*no_data\*\*" || echo 0)
 ```
 
 Output:
@@ -256,37 +368,41 @@ Output:
 ## Próximas ações
 
 {Se PAGE_COUNT > 0:}
-⚠ {PAGE_COUNT} SLO(s) em PAGE — invocar /investigar-producao "<slo_name> burn rate {burn_rate}×"
+⚠ {PAGE_COUNT} SLO(s) em PAGE (ambas janelas críticas) — invocar /investigar-producao "<slo_name> dual-window burn"
 
 {Se TICKET_COUNT > 0:}
-☐ {TICKET_COUNT} SLO(s) em TICKET — abrir issue, investigar antes do budget esgotar
+☐ {TICKET_COUNT} SLO(s) em TICKET (slow erosion sustained) — abrir issue, investigar antes do budget esgotar
 
 {Se WARN_COUNT > 0:}
-ⓘ {WARN_COUNT} SLO(s) em WARN — burn rate sustained ≥1× exhausts budget
+ⓘ {WARN_COUNT} SLO(s) em WARN — fast spike isolado ou mild burn ≥ 1× (não page; monitor)
 
 {Se NO_DATA_COUNT > 0:}
-⊘ {NO_DATA_COUNT} SLO(s) sem dados na janela — invoque o MCP tool 'metrics-snapshot' periodicamente para popular .planning/metrics/snapshots/
+⊘ {NO_DATA_COUNT} SLO(s) sem dados em pelo menos uma janela — Phase 102 auto-persist deve popular .planning/metrics/snapshots/ automaticamente em chamadas ao MCP tool 'metrics-snapshot'
 ```
 
 ## 6. Modo `/loop` (idempotência)
 
 Se chamado dentro de `/loop`, comportamento idempotente:
 - Snapshot fresh em cada invocação (não acumular state).
-- Output curto se status não mudou (apenas linha-resumo; sem repetir tabela completa).
-- Acionar AskUserQuestion APENAS quando algum SLO transiciona OK → WARN/TICKET/PAGE.
+- Output curto se `combined_status` não mudou (apenas linha-resumo; sem repetir tabela completa).
+- Acionar AskUserQuestion APENAS quando algum SLO transiciona OK → WARN/TICKET/PAGE no `combined_status`.
 
 </process>
 
 <success_criteria>
-- [ ] $ARGUMENTS parseados (SLO opcional + flags --lookahead/--baseline/--format)
+- [ ] $ARGUMENTS parseados (SLO opcional + flags --fast-baseline/--slow-baseline/--format)
 - [ ] SLOs descobertos via glob `.planning/slos/*.yml` (FIX Phase 99: extension `.yml`, não `.md`)
-- [ ] Snapshots carregados via `loadSnapshots()` (Phase 99 — `src/core/metrics.js`)
-- [ ] SLI calculado por tipo (event-based ratio para availability, percentile para latency)
-- [ ] Burn rate calculado pela fórmula `error_rate / (1 - target)` (skill burn-rate-alerting)
-- [ ] Status enum: PAGE / TICKET / WARN / OK / no_data
-- [ ] ETA exhaustão computada (predictive forecast)
-- [ ] Tabela markdown agregada
-- [ ] Sugestões de próximas ações para SLOs em alerta
-- [ ] Idempotente em /loop (sem acúmulo de state)
-- [ ] no_data graceful — não inventa números, sugere `metrics-snapshot`
+- [ ] alert_thresholds.page (fast) + alert_thresholds.ticket (slow) extraídos via awk com state machine
+- [ ] Defensive defaults aplicados (14.4 / 6 / 1h / 6h) se YAML omitir blocos
+- [ ] Snapshots carregados via `loadSnapshots()` em DUAS chamadas (fast + slow)
+- [ ] SLI calculado por tipo (event-based ratio para availability, percentile para latency) em CADA janela
+- [ ] Burn rate calculado pela fórmula `error_rate / (1 - target)` (skill [`burn-rate-alerting`](../skills/burn-rate-alerting/SKILL.md)) para fast E slow independentemente
+- [ ] Status combinado dual-window: **PAGE** (ambos críticos) / **TICKET** (slow only) / **WARN** (fast only OR mild ≥ 1×) / **OK** (ambos < 1×) / **no_data** (qualquer janela com snapshots insuficientes)
+- [ ] Tabela markdown agregada com colunas Fast (1h) / Slow (6h) / Combined explícitas
+- [ ] ETA exhaustão computada (predictive forecast — usa slow window por estabilidade)
+- [ ] Sugestões de próximas ações contextualizadas pelo combined_status
+- [ ] Idempotente em /loop (sem acúmulo de state; transição combined_status dispara AskUserQuestion)
+- [ ] no_data graceful — Phase 102 auto-persist mencionado como solução
+- [ ] Skill burn-rate-alerting cross-referenced no objective + inline no node script + inline na tabela de fallback (3 hits ≥ 2 mínimo)
+- [ ] Fator 4× explícito no contexto (canonical Google SRE)
 </success_criteria>