@luanpdd/kit-mcp 1.9.0 → 1.11.0

package/gates/observability-coverage.md

@@ -0,0 +1,151 @@
+---
+id: observability-coverage
+stage: pre-milestone-close
+blocking: false
+description: Valida que ≥ X% das Edge Functions têm 4 golden signals + SLO + burn alert + characterization. Default threshold 70%. Opt-in via workflow.observability_coverage_threshold.
+---
+
+# Observability coverage gate (cross-suite)
+
+**When to run:** pre-milestone-close (consultive default; blocking se `workflow.observability_coverage_threshold > 0`).
+
+**Skills canônicas:** [`four-golden-signals`](../kit/skills/four-golden-signals/SKILL.md), [`event-based-slos`](../kit/skills/event-based-slos/SKILL.md), [`burn-rate-alerting`](../kit/skills/burn-rate-alerting/SKILL.md), [`legacy-characterization-tests`](../kit/skills/legacy-characterization-tests/SKILL.md)
+
+**Agent invocado:** [`observability-coverage-auditor`](../kit/agents/observability-coverage-auditor.md)
+
+## Check
+
+```bash
+#!/usr/bin/env bash
+# PT-BR: validar cobertura cross-suite de Edge Functions
+set -e
+
+# threshold do gate
+THRESHOLD=70
+if [ -f ".planning/config.json" ] && command -v jq >/dev/null; then
+  CFG=$(jq -r '.workflow.observability_coverage_threshold // empty' .planning/config.json 2>/dev/null)
+  [ -n "$CFG" ] && [ "$CFG" != "null" ] && THRESHOLD=$CFG
+fi
+
+# se threshold = 0, gate skip (opt-in)
+if [ "$THRESHOLD" -eq 0 ]; then
+  echo "INFO: workflow.observability_coverage_threshold=0 — gate skip (opt-in não habilitado)."
+  exit 0
+fi
+
+# enumerar Edge Functions
+NUM_EDGE_FNS=$(find supabase/functions -mindepth 1 -maxdepth 1 -type d 2>/dev/null | wc -l)
+if [ "$NUM_EDGE_FNS" -eq 0 ]; then
+  echo "INFO: nenhuma Edge Function detectada — gate skip."
+  exit 0
+fi
+
+# contar Edge Functions cobertas em cada dimensão
+COVERED_SIGNALS=0
+COVERED_SLO=0
+COVERED_BURN=0
+COVERED_CHAR=0
+
+for fn_dir in $(find supabase/functions -mindepth 1 -maxdepth 1 -type d 2>/dev/null); do
+  FN_NAME=$(basename "$fn_dir")
+  FN_FILE="$fn_dir/index.ts"
+  [ ! -f "$FN_FILE" ] && continue
+
+  # 4 golden signals
+  HAS_LATENCY=$(grep -qE "createHistogram|histogram.*ms|latency_histogram" "$FN_FILE" && echo true || echo false)
+  HAS_TRAFFIC=$(grep -qE "createCounter.*requests|http_requests_total|trafficCounter" "$FN_FILE" && echo true || echo false)
+  HAS_ERRORS=$(grep -qE "createCounter.*errors|http_errors_total|error_type" "$FN_FILE" && echo true || echo false)
+  HAS_SAT=$(grep -qE "createObservableGauge|connection_pool|queue_depth" "$FN_FILE" && echo true || echo false)
+  if [ "$HAS_LATENCY" = "true" ] && [ "$HAS_TRAFFIC" = "true" ] && [ "$HAS_ERRORS" = "true" ] && [ "$HAS_SAT" = "true" ]; then
+    COVERED_SIGNALS=$((COVERED_SIGNALS + 1))
+  fi
+
+  # SLO
+  if [ -f ".planning/slos/$FN_NAME.md" ] || ([ -f ".planning/SLO.md" ] && grep -q "$FN_NAME" ".planning/SLO.md"); then
+    COVERED_SLO=$((COVERED_SLO + 1))
+  fi
+
+  # Burn alert
+  if grep -rq "$FN_NAME" .planning/burn-rate-alerts.md .planning/SLO.md 2>/dev/null; then
+    COVERED_BURN=$((COVERED_BURN + 1))
+  fi
+
+  # Characterization
+  for chardir in tests/characterization test/characterization __tests__/characterization; do
+    if find "$chardir" -path "*$FN_NAME*" 2>/dev/null | head -1 | grep -q .; then
+      COVERED_CHAR=$((COVERED_CHAR + 1))
+      break
+    fi
+  done
+done
+
+# computar percentages
+PCT_SIGNALS=$((COVERED_SIGNALS * 100 / NUM_EDGE_FNS))
+PCT_SLO=$((COVERED_SLO * 100 / NUM_EDGE_FNS))
+PCT_BURN=$((COVERED_BURN * 100 / NUM_EDGE_FNS))
+PCT_CHAR=$((COVERED_CHAR * 100 / NUM_EDGE_FNS))
+
+# avg
+PCT_AVG=$(( (PCT_SIGNALS + PCT_SLO + PCT_BURN + PCT_CHAR) / 4 ))
+
+echo ""
+echo "observability-coverage gate — threshold: ${THRESHOLD}%"
+echo ""
+echo "  4 Golden Signals:        ${COVERED_SIGNALS}/${NUM_EDGE_FNS} (${PCT_SIGNALS}%)"
+echo "  SLO definido:            ${COVERED_SLO}/${NUM_EDGE_FNS} (${PCT_SLO}%)"
+echo "  Burn rate alert:         ${COVERED_BURN}/${NUM_EDGE_FNS} (${PCT_BURN}%)"
+echo "  Characterization tests:  ${COVERED_CHAR}/${NUM_EDGE_FNS} (${PCT_CHAR}%)"
+echo ""
+echo "  Avg coverage: ${PCT_AVG}%"
+echo ""
+
+# decisão
+if [ "$PCT_AVG" -ge "$THRESHOLD" ]; then
+  echo "✓ Avg ≥ threshold (${PCT_AVG}% ≥ ${THRESHOLD}%). Gate aprovado."
+  exit 0
+fi
+
+echo "⚠ Avg < threshold (${PCT_AVG}% < ${THRESHOLD}%)."
+echo ""
+echo "Próximas ações:"
+echo "  /auditar-observabilidade-cobertura      (vê detalhes + top 5 críticas)"
+echo "  /golden-signals <fn>                    (instrumentar 4 signals)"
+echo "  /definir-slo <fn>                       (define SLO event-based)"
+echo "  /caracterizar <fn>                      (characterization tests)"
+echo ""
+
+# blocking se threshold > 0 e não atingido
+if [ "$THRESHOLD" -gt 0 ]; then
+  exit 1
+fi
+
+exit 0
+```
+
+## Configuração
+
+```json
+{
+  "workflow": {
+    "observability_coverage_threshold": 70
+  }
+}
+```
+
+**Default:** `0` (skip — opt-in). Recomendação:
+- Projetos < 6 meses: 50 (consultive)
+- Projetos 6-12 meses: 70
+- Projetos > 12 meses ou tier-1 production: 80+
+
+## Quando NÃO rodar
+
+- Projeto sem Edge Functions (puro frontend/backend stateless)
+- Projeto recém-criado (< 1 mês) — distribuição de Edge Functions ainda imatura
+- Greenfield onde Edge Functions estão sendo escritas em paralelo a milestones
+
+## Ver também
+
+- [`observability-coverage-auditor`](../kit/agents/observability-coverage-auditor.md) — agent canônico
+- [`/auditar-observabilidade-cobertura`](../kit/commands/auditar-observabilidade-cobertura.md) — comando dedicado
+- [`omm-no-regression`](./omm-no-regression.md) — gate análogo da Suíte Observabilidade
+- [`golden-signals-coverage`](./golden-signals-coverage.md) — gate específico apenas para golden signals

package/gates/postmortem-template-required.md

@@ -0,0 +1,127 @@
+---
+id: postmortem-template-required
+stage: pre-conclude
+blocking: true
+description: Bloqueia /concluir-marco se há investigação em .planning/investigations/ sem postmortem correspondente em .planning/postmortems/. "No postmortem left unreviewed" (cap 15).
+---
+
+# Postmortem template required gate
+
+**When to run:** pre-conclude (blocking — milestone NÃO arquiva até cada incident ter postmortem blameless).
+
+## Check
+
+```bash
+#!/usr/bin/env bash
+# PT-BR: validar que cada investigação em .planning/investigations/ tem postmortem em .planning/postmortems/.
+# Match por basename (sem extensão .md). Investigations com Status: INCONCLUSIVE são exceção.
+# Bash 3.2-portable (macOS default).
+set -e
+
+INV_DIR=".planning/investigations"
+PM_DIR=".planning/postmortems"
+
+# PT-BR: se não há investigations, gate passa com INFO
+if [ ! -d "$INV_DIR" ]; then
+  echo "INFO: $INV_DIR não existe — projeto sem incidents registrados. Gate skipped."
+  exit 0
+fi
+
+# PT-BR: listar investigations (single-file *.md OR subdir com STATE.md)
+INVESTIGATIONS=""
+
+# PT-BR: pattern A — .planning/investigations/<id>.md (single file)
+SINGLE_FILES=$(find "$INV_DIR" -maxdepth 1 -type f -name "*.md" 2>/dev/null || true)
+if [ -n "$SINGLE_FILES" ]; then
+  INVESTIGATIONS="$INVESTIGATIONS
+$SINGLE_FILES"
+fi
+
+# PT-BR: pattern B — .planning/investigations/<id>/STATE.md (subdir state)
+SUBDIR_STATES=$(find "$INV_DIR" -mindepth 2 -maxdepth 2 -type f -name "STATE.md" 2>/dev/null || true)
+if [ -n "$SUBDIR_STATES" ]; then
+  INVESTIGATIONS="$INVESTIGATIONS
+$SUBDIR_STATES"
+fi
+
+# PT-BR: filtrar linhas vazias
+INVESTIGATIONS=$(echo "$INVESTIGATIONS" | grep -v "^$" || true)
+
+if [ -z "$INVESTIGATIONS" ]; then
+  echo "INFO: $INV_DIR vazio — sem incidents registrados. Gate skipped."
+  exit 0
+fi
+
+# PT-BR: para cada investigation, extrair <id> e checar postmortem correspondente
+MISSING=0
+MISSING_LIST=""
+OLDIFS="$IFS"
+IFS='
+'
+for inv_path in $INVESTIGATIONS; do
+  [ -z "$inv_path" ] && continue
+  [ ! -f "$inv_path" ] && continue
+
+  # PT-BR: extrair <id> — basename sem .md OU dirname se for STATE.md em subdir
+  base=$(basename "$inv_path")
+  if [ "$base" = "STATE.md" ]; then
+    # pattern B — id é o nome do subdir parent
+    id=$(basename "$(dirname "$inv_path")")
+  else
+    # pattern A — id é basename sem .md
+    id="${base%.md}"
+  fi
+
+  # PT-BR: se investigation tem Status: INCONCLUSIVE (sem root cause), pular
+  if grep -qiE "^Status:.*INCONCLUSIVE|^.*Status.*INCONCLUSIVE" "$inv_path" 2>/dev/null; then
+    echo "INFO: investigation '$id' marcada INCONCLUSIVE — sem root cause, postmortem não exigido."
+    continue
+  fi
+
+  # PT-BR: postmortem esperado em .planning/postmortems/<id>.md
+  pm_path="$PM_DIR/$id.md"
+  if [ ! -f "$pm_path" ]; then
+    MISSING=$((MISSING + 1))
+    MISSING_LIST="$MISSING_LIST $id"
+  fi
+done
+IFS="$OLDIFS"
+
+if [ "$MISSING" -eq 0 ]; then
+  echo "PASS: todas as investigações têm postmortem correspondente em $PM_DIR/"
+  exit 0
+else
+  echo "FAIL: $MISSING investigação(ões) sem postmortem em $PM_DIR/:$MISSING_LIST"
+  echo "Sugestão: rodar /postmortem --from-investigation <id> para cada item ausente."
+  echo "Cross-ref: kit/skills/blameless-postmortems/SKILL.md + kit/agents/postmortem-writer.md"
+  echo "Princípio canônico: 'No postmortem left unreviewed' (cap 15 livro Google SRE)."
+  exit 1
+fi
+```
+
+## Verdict
+
+- **passed** — todas investigations têm postmortem correspondente OR investigations marcadas INCONCLUSIVE OR diretório `.planning/investigations/` ausente
+- **block** — pelo menos 1 investigation sem postmortem em `.planning/postmortems/`
+
+## Why
+
+O livro Google SRE (cap 15 — *Postmortem Culture: Learning from Failure*) define como princípio canônico **"no postmortem left unreviewed"**: cada incident significativo (registrado como investigação via `/forense` + `incident-investigator` v1.9) deve gerar postmortem blameless documentando *o que aprendemos* e *o que mudaremos*.
+
+Sem este gate, milestones arquivam com investigations órfãs — root cause foi diagnosticado mas aprendizado organizacional perdeu-se (anti-pattern hero culture: "fixei o bug, vamos seguir"). Gate força a chain canônica entre v1.9 (Core Analysis Loop diagnostica) e v1.10 (postmortem documenta).
+
+Cross-ref agent canônico: [`postmortem-writer`](../kit/agents/postmortem-writer.md) (Phase 37 / AGCORE-SRE-03). Skill: [`blameless-postmortems`](../kit/skills/blameless-postmortems/SKILL.md) (Phase 36 / SKFD-SRE-04). Comando: `/postmortem --from-investigation <id>` (Phase 38 / CMD-SRE-03). Chain documentado em `kit/commands/forense.md` bloco `<sre_integration>` (Plan 40-01 / INT-FW-V2-01).
+
+## REQ
+
+QA-SRE-02.
+
+## Configuração
+
+Gate é **blocking** por default (cultura SRE blameless é não-negociável uma vez instituída). Para tornar warn-only durante adoption inicial:
+
+```bash
+node ./.claude/framework/bin/tools.cjs config-set workflow.postmortem_required_warn true
+```
+
+(Nota: implementação do toggle warn-only é deferida — gate atual lê apenas presença/ausência de pares investigation↔postmortem, não consulta config.)

package/gates/prr-checklist-coverage.md

@@ -0,0 +1,128 @@
+---
+id: prr-checklist-coverage
+stage: pre-verify
+blocking: true
+description: Valida que cada PRR-REPORT.md em .planning/prr/ cobre os 6 axes canonicos (System Architecture/Instrumentation/Emergency/Capacity/Change/Performance — cap 32 livro Google SRE).
+---
+
+# PRR checklist coverage gate
+
+**When to run:** pre-verify (blocking — PRR sem 6 axes = aprovação inválida).
+
+## Check
+
+```bash
+#!/usr/bin/env bash
+# PT-BR: validar que cada PRR-REPORT.md em .planning/prr/**/*.md cobre os 6 axes do PRR.
+# Match por palavra-chave em heading H2 (case-insensitive). Pular um axe = aprovação inválida.
+# Bash 3.2-portable (macOS default).
+set -e
+
+PRR_DIR=".planning/prr"
+
+# PT-BR: se não há PRR reports, gate passa com INFO
+if [ ! -d "$PRR_DIR" ]; then
+  echo "INFO: $PRR_DIR não existe — projeto sem PRR reports. Gate skipped."
+  exit 0
+fi
+
+# PT-BR: listar todos os *.md em .planning/prr/ recursivamente
+PRR_FILES=$(find "$PRR_DIR" -type f -name "*.md" 2>/dev/null || true)
+PRR_FILES=$(echo "$PRR_FILES" | grep -v "^$" || true)
+
+if [ -z "$PRR_FILES" ]; then
+  echo "INFO: $PRR_DIR vazio — sem PRR reports. Gate skipped."
+  exit 0
+fi
+
+# PT-BR: para cada PRR report, validar que cobre os 6 axes
+VIOLATIONS=0
+OLDIFS="$IFS"
+IFS='
+'
+for prr_file in $PRR_FILES; do
+  [ -z "$prr_file" ] && continue
+  [ ! -f "$prr_file" ] && continue
+
+  # PT-BR: extrair headings H2 (case-insensitive)
+  H2=$(grep -E "^## " "$prr_file" 2>/dev/null || true)
+
+  # PT-BR: 6 axes — match em palavras-chave (qualquer variante aceitável)
+  AXE_MISSING=""
+
+  # Axe 1: System Architecture
+  if ! echo "$H2" | grep -qiE "system.*architecture|architecture"; then
+    AXE_MISSING="$AXE_MISSING Axe1(SystemArchitecture)"
+  fi
+
+  # Axe 2: Instrumentation / Metrics / Monitoring
+  if ! echo "$H2" | grep -qiE "instrumentation|metrics|monitoring"; then
+    AXE_MISSING="$AXE_MISSING Axe2(Instrumentation)"
+  fi
+
+  # Axe 3: Emergency Response
+  if ! echo "$H2" | grep -qiE "emergency.*response|emergency"; then
+    AXE_MISSING="$AXE_MISSING Axe3(EmergencyResponse)"
+  fi
+
+  # Axe 4: Capacity Planning
+  if ! echo "$H2" | grep -qiE "capacity.*planning|capacity"; then
+    AXE_MISSING="$AXE_MISSING Axe4(CapacityPlanning)"
+  fi
+
+  # Axe 5: Change Management
+  if ! echo "$H2" | grep -qiE "change.*management|change"; then
+    AXE_MISSING="$AXE_MISSING Axe5(ChangeManagement)"
+  fi
+
+  # Axe 6: Performance
+  if ! echo "$H2" | grep -qiE "performance"; then
+    AXE_MISSING="$AXE_MISSING Axe6(Performance)"
+  fi
+
+  if [ -n "$AXE_MISSING" ]; then
+    echo "FAIL: $prr_file — axes ausentes:$AXE_MISSING"
+    VIOLATIONS=$((VIOLATIONS + 1))
+  fi
+done
+IFS="$OLDIFS"
+
+if [ "$VIOLATIONS" -eq 0 ]; then
+  total=$(echo "$PRR_FILES" | wc -l | tr -d ' ')
+  echo "PASS: $total PRR-REPORT(s) cobrem os 6 axes canônicos"
+  exit 0
+else
+  echo "FAIL: $VIOLATIONS PRR-REPORT(s) com axes ausentes"
+  echo "Sugestão: rodar /sre prr <service> ou /prr para regenerar com template canônico (6 axes obrigatórios)."
+  echo "Cross-ref: kit/skills/production-readiness-review/SKILL.md + kit/agents/prr-conductor.md"
+  echo "Princípio canônico: 'Pular um axe = aprovação inválida' (cap 32 livro Google SRE)."
+  exit 1
+fi
+```
+
+## Verdict
+
+- **passed** — cada PRR-REPORT.md em `.planning/prr/**/*.md` tem H2 cobrindo os 6 axes (System Architecture / Instrumentation / Emergency Response / Capacity Planning / Change Management / Performance) OR diretório `.planning/prr/` ausente
+- **block** — pelo menos 1 PRR-REPORT.md com axe(s) ausente(s)
+
+## Why
+
+O livro Google SRE (cap 32 — *Evolving SRE Engagement Model*) define **6 axes canônicos** do Production Readiness Review. A skill `production-readiness-review` (Phase 36 / SKFD-SRE-05) declara como regra absoluta: *"Pular um axe = aprovação inválida (lacuna oculta vira incident em 6 meses)"*.
+
+Sem este gate, PRRs apressados podem omitir axes "menos relevantes" (anti-pattern documentado na skill); gaps em Change Management ou Capacity Planning não detectados em PRR viram incidents em produção meses depois. Gate força padrão canônico — cada `PRR-REPORT.md` cobrindo os 6 axes integralmente, mesmo que items dentro de um axe sejam N/A para o serviço (justificativa explícita no item, não no axe).
+
+Cross-ref agent canônico: [`prr-conductor`](../kit/agents/prr-conductor.md) (Phase 37 / AGCORE-SRE-04). Skill: [`production-readiness-review`](../kit/skills/production-readiness-review/SKILL.md) (Phase 36 / SKFD-SRE-05). Comando: `/prr --service <name>` ou `/prr --feature <description>` (Phase 38 / CMD-SRE-04).
+
+## REQ
+
+QA-SRE-03.
+
+## Configuração
+
+Gate é **blocking** por default. Para tornar warn-only durante adoption inicial:
+
+```bash
+node ./.claude/framework/bin/tools.cjs config-set workflow.prr_checklist_coverage_warn true
+```
+
+(Nota: implementação do toggle warn-only é deferida — gate atual não consulta config.)

package/gates/release-pipeline-policy.md

@@ -0,0 +1,132 @@
+---
+id: release-pipeline-policy
+stage: pre-milestone-close
+blocking: false
+description: Valida release pipeline scored ≥ X/30 (default 20 = ADEQUATE) em hermeticidade + reprodutibilidade + policy enforcement. Opt-in via workflow.complete_milestone_release_pipeline_gate. Cap 8 livro Google SRE.
+---
+
+# Release pipeline policy gate
+
+**When to run:** pre-milestone-close (consultive default; blocking se `workflow.complete_milestone_release_pipeline_gate=true`).
+
+**Skill canônica:** [`release-engineering`](../kit/skills/release-engineering/SKILL.md) + [`hermetic-builds`](../kit/skills/hermetic-builds/SKILL.md)
+
+**Agent invocado:** [`release-pipeline-auditor`](../kit/agents/release-pipeline-auditor.md)
+
+## Check
+
+```bash
+#!/usr/bin/env bash
+# PT-BR: validar release pipeline scored >= threshold
+set -e
+
+# threshold do gate
+THRESHOLD=20  # default: ADEQUATE
+GATE_BLOCKING=false
+
+if [ -f ".planning/config.json" ] && command -v jq >/dev/null; then
+  CFG=$(jq -r '.workflow.complete_milestone_release_pipeline_gate // empty' .planning/config.json 2>/dev/null)
+  if [ "$CFG" = "true" ]; then
+    GATE_BLOCKING=true
+  fi
+  CFG_THRESH=$(jq -r '.workflow.release_pipeline_threshold // empty' .planning/config.json 2>/dev/null)
+  [ -n "$CFG_THRESH" ] && [ "$CFG_THRESH" != "null" ] && THRESHOLD=$CFG_THRESH
+fi
+
+# se não opt-in, gate skip
+if [ "$GATE_BLOCKING" = false ] && [ -z "$RELEASE_PIPELINE_POLICY_FORCE" ]; then
+  echo "INFO: release-pipeline-policy gate is opt-in (workflow.complete_milestone_release_pipeline_gate=false). Skip."
+  exit 0
+fi
+
+# ler RELEASE-AUDIT.md OR delegar via Task se ausente/stale
+AUDIT_FILE=".planning/RELEASE-AUDIT.md"
+SCORE=""
+
+if [ -f "$AUDIT_FILE" ]; then
+  # check se fresh (≤ 30 dias)
+  if [ "$(uname)" = "Darwin" ]; then
+    AUDIT_DATE=$(stat -f %m "$AUDIT_FILE")
+  else
+    AUDIT_DATE=$(stat -c %Y "$AUDIT_FILE")
+  fi
+  AGE_DAYS=$(( ($(date +%s) - AUDIT_DATE) / 86400 ))
+
+  if [ "$AGE_DAYS" -gt 30 ]; then
+    echo "⚠ RELEASE-AUDIT.md stale (${AGE_DAYS}d). Re-rodar /auditar-release antes de close."
+    [ "$GATE_BLOCKING" = true ] && exit 1
+  fi
+
+  # parse score
+  SCORE=$(grep -oE "Score:\*\*\s*[0-9]+/30" "$AUDIT_FILE" | grep -oE "[0-9]+" | head -1)
+fi
+
+if [ -z "$SCORE" ]; then
+  echo "⚠ RELEASE-AUDIT.md ausente OR sem score parseável."
+  echo "Rode: /auditar-release  (gera relatório fresh)"
+  [ "$GATE_BLOCKING" = true ] && exit 1
+  exit 0
+fi
+
+echo ""
+echo "release-pipeline-policy gate — threshold: ${THRESHOLD}/30"
+echo "  RELEASE-AUDIT.md score: ${SCORE}/30"
+echo ""
+
+# decisão
+if [ "$SCORE" -ge "$THRESHOLD" ]; then
+  if [ "$SCORE" -ge 25 ]; then
+    echo "✓ ROBUST (≥ 25/30) — milestone arquivável."
+  else
+    echo "✓ ADEQUATE (20-24) — milestone arquivável com warnings."
+  fi
+  exit 0
+fi
+
+if [ "$SCORE" -lt 15 ]; then
+  echo "✗ BROKEN (< 15/30) — pipeline não pode ser fonte de verdade. ESCALAR."
+elif [ "$SCORE" -lt 20 ]; then
+  echo "✗ FRAGILE (15-19/30) — gaps significativos."
+fi
+
+echo ""
+echo "Próximas ações:"
+echo "  1. Aplicar top 5 fixes do RELEASE-AUDIT.md"
+echo "  2. Re-rodar /auditar-release"
+echo "  3. Re-tentar /concluir-marco após score >= ${THRESHOLD}"
+echo ""
+
+[ "$GATE_BLOCKING" = true ] && exit 1
+exit 0
+```
+
+## Configuração
+
+```json
+{
+  "workflow": {
+    "complete_milestone_release_pipeline_gate": false,
+    "release_pipeline_threshold": 20
+  }
+}
+```
+
+**Default:** `complete_milestone_release_pipeline_gate=false` (opt-in). Threshold 20 = ADEQUATE; promove para 25 (ROBUST) em projetos tier-1.
+
+## Quando NÃO rodar
+
+- Projeto < 6 meses (pipeline ainda imatura)
+- Releases manuais (sem CI/CD complexo)
+- Solo dev side project
+- Projeto puramente experimental
+
+## Ver também
+
+- [`release-pipeline-auditor`](../kit/agents/release-pipeline-auditor.md) — agent canônico
+- [`/auditar-release`](../kit/commands/auditar-release.md) — comando dedicado
+- [`hermetic-builds`](../kit/skills/hermetic-builds/SKILL.md)
+- [`release-engineering`](../kit/skills/release-engineering/SKILL.md)
+- [`prr-checklist-coverage`](./prr-checklist-coverage.md) — gate análogo PRR (v1.10)
+- [`legacy-refactor-safety`](./legacy-refactor-safety.md) — gate análogo Legacy (v1.12)
+
+*Material-fonte: cap 8 livro Google SRE.*

package/kit/COMANDOS.md

@@ -112,6 +112,21 @@
 | `/definir-perfil` | Altera o perfil de modelo para os agentes framework (quality/balanced/budget/inherit) |
 | `/configuracoes` | Configura os toggles de workflow framework e perfil de modelo |
 
+## Suíte Legacy Code (Feathers + modernizações IA/Supabase 2026)
+
+| Comando | O que faz |
+|---------|-----------|
+| `/legacy <subcomando>` | Orquestrador único — dispatch para agents da suíte (10 subcomandos com sinônimos PT/EN) |
+| `/caracterizar` | Gera characterization tests (cap 13) — golden snapshots cobrindo 7 grupos de equivalência |
+| `/encontrar-seams` | Identifica seams (cap 25) e recomenda técnica de dependency-breaking |
+| `/auditar-refactor` | Gate canônico — coleta evidências e retorna veredito GO/BLOCK/WARN/GO-OVERRIDE |
+| `/refactor-seguro` | Chain canônico — seams → caracterizar → auditar → executar; modos full/sprout/safe-extract/override |
+| `/capturar-payloads` | Instrumenta Edge Function Supabase para captura de payloads reais via mcp__supabase__get_logs (modernização) |
+| `/caracterizar-prompt` | Characterization de prompts/tools LLM com temperature=0 + seed fixo (modernização IA) |
+| `/storytelling` | IA gera mental model + naked CRC + extract candidates (cap 16-17 + modernização IA) |
+| `/detectar-duplicacao` | Shotgun surgery cross-codebase via embeddings + jscpd (cap 21 + modernização IA) |
+| `/auditar-observabilidade-cobertura` | Audit X/N Edge Functions com signals + SLO + burn alert + char (cross-suite) |
+
 ## Utilitários
 
 | Comando | O que faz |