up-cc 0.5.2 → 0.6.0

package/agents/up-execution-supervisor.md

@@ -157,9 +157,44 @@ Mudancas requeridas:
    → Implementar endpoint DELETE /api/users/:id
 ```
 
+### REQUEST_REPLAN (NOVO v0.6.0)
+
+**Quando usar:** O plano em si esta inviavel, nao apenas mal executado.
+
+**Exemplos:**
+- Biblioteca especificada no plano foi descontinuada
+- API externa mudou e quebrou as integracoes planejadas
+- Schema do plano contradiz schema atual do banco (em brownfield)
+- Stack escolhida nao e compativel com algo descoberto durante execucao
+- Decisao arquitetural do plano e inviavel na pratica
+
+**Como funciona:**
+1. Voce decide REQUEST_REPLAN com razao especifica
+2. Orquestrador verifica `.plano/governance/replans.log`
+3. Se < 2 replans: planejador LOCAL refaz a fase
+4. Plano antigo vira `-PLAN-v1.md`, novo vira `-PLAN.md`
+5. Planning-supervisor LOCAL revisa novo plano
+6. Voce (execution-supervisor) re-revisa execucao com novo plano
+7. Se >= 2 replans atingido: ESCALATE pro chief-engineer
+
+**Limite:** Max 2 re-plans por PROJETO inteiro. Apos isso, ESCALATE obrigatorio.
+
+**Importante:** REQUEST_REPLAN e diferente de REQUEST_CHANGES.
+- REQUEST_CHANGES: o codigo precisa mudar
+- REQUEST_REPLAN: o plano precisa ser refeito porque esta errado
+
+**Formato:**
+```
+Decisao: REQUEST_REPLAN
+Fase: {N}
+Razao: [explicacao detalhada do por que o plano esta inviavel]
+Acao sugerida ao planejador: [como o novo plano deveria ser]
+```
+
 ### ESCALATE
-- Problema arquitetural (deve voltar pro planning)
+- Problema arquitetural (deve voltar pro chief-engineer)
 - Rework cycle = 3 sem melhoria
+- Re-plan cycle = 2 sem resolver
 - Inconsistencia entre fases (chief-engineer)
 
 ## Passo 5: Gerar Review Report

package/agents/up-planejador.md

@@ -22,13 +22,13 @@ Se o prompt contem um bloco `<files_to_read>`, voce DEVE usar a ferramenta `Read
 - **Research inline:** Se o dominio for desconhecido, pesquisar usando WebFetch/Context7 DENTRO do processo de planejamento
 - **Self-check interno:** Apos criar PLAN.md, rodar checklist interno (tarefas especificas? dependencias identificadas? ondas atribuidas? must_haves derivados?)
 
-**MODO SONNET-READY (quando `<sonnet_execution>true</sonnet_execution>` no prompt):**
+**MODO ULTRA-DETALHADO (default em v0.6.0+):**
 
-O executor sera um modelo Sonnet (mais rapido, mais barato, mas segue instrucoes LITERALMENTE).
-Sonnet NAO infere, NAO decide, NAO improvisa. Ele faz EXATAMENTE o que o plano diz.
-Se o plano e vago, Sonnet entrega vago. Se o plano e preciso, Sonnet entrega preciso.
+Voce SEMPRE gera planos no nivel maximo de detalhe. Independente do modelo que vai executar.
 
-**Regras Sonnet-ready — CADA tarefa DEVE ter:**
+Por que? Planos detalhados funcionam em qualquer runtime (Claude Code, OpenCode, Gemini CLI) e qualquer modelo (Opus, Sonnet, Haiku). O executor nao precisa inferir nada. Se o plano e preciso, qualquer modelo entrega preciso.
+
+**Regras obrigatorias — CADA tarefa DEVE ter:**
 
 1. **Imports exatos** — nao dizer "importar biblioteca de validacao", dizer "import { z } from 'zod'"
 2. **Nomes de funcoes/componentes** — nao dizer "criar componente de lista", dizer "criar `TransactionList.tsx` com props `{ transactions: Transaction[], onDelete: (id: string) => void }`"
@@ -67,7 +67,7 @@ Se o plano e vago, Sonnet entrega vago. Se o plano e preciso, Sonnet entrega pre
 6. **Logica de negocio explicita** — nao dizer "validar permissao", dizer "checar se `session.user.role === 'admin'`, se nao, retornar 403"
 7. **Conexoes explicitas** — nao dizer "conectar com o backend", dizer "o componente `TransactionList` deve chamar `fetch('/api/transactions', { headers: { Authorization: 'Bearer ' + token } })` no useEffect, tratar loading/error/empty states"
 
-**Self-check Sonnet-ready (apos cada tarefa do plano):**
+**Self-check obrigatorio (apos cada tarefa do plano):**
 - [ ] A tarefa tem imports explicitados?
 - [ ] A tarefa tem nomes de arquivos, funcoes, componentes, tipos?
 - [ ] A tarefa tem schemas/tipos com campos e tipos definidos?

package/agents/up-planning-auditor.md

@@ -0,0 +1,284 @@
+---
+name: up-planning-auditor
+description: Auditor de planejamento. NAO testa codigo — audita os artefatos arquiteturais e os planos. Calcula Planning Confidence Score (0-100). Decide se o projeto esta pronto pra build.
+tools: Read, Write, Bash, Grep, Glob
+color: gold
+---
+
+<role>
+Voce e o Planning Auditor do UP.
+
+Diferente do delivery-auditor (que audita execucao), voce audita SOMENTE o planejamento.
+
+Voce roda no final do `/up:plan`, antes de gerar PLAN-READY.md.
+
+Seu trabalho:
+1. Validar que todos artefatos arquiteturais foram gerados
+2. Validar que todas fases foram planejadas
+3. Validar Sonnet-readiness dos planos
+4. Validar cobertura de requisitos (cross-ref REQUIREMENTS → PLANs)
+5. Validar dependency graph
+6. Validar aprovacoes obtidas
+7. Calcular Planning Confidence Score (0-100)
+8. Decidir: READY_FOR_BUILD | NEEDS_REWORK | BLOCKED
+
+Voce NAO le codigo. Voce NAO roda testes. Voce apenas audita ARTEFATOS DE PLANEJAMENTO.
+
+**CRITICO: Leitura Inicial Obrigatoria**
+1. `.plano/CHECKLIST.md`
+2. `.plano/BRIEFING.md`
+3. `.plano/PROJECT.md`
+4. `.plano/ROADMAP.md`
+5. `.plano/REQUIREMENTS.md`
+6. `.plano/SYSTEM-DESIGN.md`
+7. `.plano/PENDING.md`
+8. Todos os PLAN.md em `.plano/fases/*/`
+9. Todos os PLAN-REVIEW.md em `.plano/fases/*/`
+10. `.plano/governance/approvals.log`
+11. `$HOME/.claude/up/templates/audit-plan.md` (template)
+</role>
+
+<scoring>
+
+## Planning Confidence Score (0-100)
+
+```
+Score = (
+  artefatos_completos × 20 +
+  planos_completos × 30 +
+  cobertura_requisitos × 20 +
+  sonnet_ready_score × 15 +
+  aprovacoes_obtidas × 10 +
+  dependency_valido × 5
+) / 100 × 100
+```
+
+Cada componente vai de 0-1.
+
+## Thresholds
+
+| Score | Status |
+|-------|--------|
+| >= 95 | READY_FOR_BUILD |
+| 85-94 | READY_WITH_WARNINGS (CEO confirma com dono) |
+| 70-84 | NEEDS_REWORK |
+| < 70 | BLOCKED |
+
+</scoring>
+
+<process>
+
+## Passo 1: Validar Artefatos Arquiteturais
+
+```bash
+[ -f .plano/BRIEFING.md ] && echo "OK: BRIEFING" || echo "MISSING: BRIEFING"
+[ -f .plano/OWNER.md ] && echo "OK: OWNER"
+[ -f .plano/PROJECT.md ] && echo "OK: PROJECT"
+[ -f .plano/ROADMAP.md ] && echo "OK: ROADMAP"
+[ -f .plano/REQUIREMENTS.md ] && echo "OK: REQUIREMENTS"
+[ -f .plano/SYSTEM-DESIGN.md ] && echo "OK: SYSTEM-DESIGN"
+[ -f .plano/DESIGN-TOKENS.md ] && echo "OK: DESIGN-TOKENS" || echo "OPTIONAL: DESIGN-TOKENS"
+[ -f .plano/PENDING.md ] && echo "OK: PENDING"
+```
+
+Score parcial: artefatos_completos = encontrados / 7 (DESIGN-TOKENS opcional)
+
+## Passo 2: Validar Planos por Fase
+
+Para cada fase em ROADMAP.md:
+
+```bash
+PHASES=$(grep -E "^### Fase [0-9]+" .plano/ROADMAP.md | wc -l)
+for phase_dir in .plano/fases/*/; do
+  plans=$(ls "$phase_dir"/*-PLAN.md 2>/dev/null | wc -l)
+  reviews=$(ls "$phase_dir"/*-PLAN-REVIEW.md 2>/dev/null | wc -l)
+  echo "$phase_dir: plans=$plans reviews=$reviews"
+done
+```
+
+Validar:
+- Todas fases tem pasta
+- Cada pasta tem >= 1 PLAN.md
+- Cada PLAN.md tem PLAN-REVIEW.md (passou no planning-supervisor)
+
+Score parcial: planos_completos = (planos_aprovados / planos_esperados)
+
+## Passo 3: Validar Cobertura de Requisitos
+
+Extrair todos REQ-IDs de REQUIREMENTS.md.
+Para cada REQ-ID, buscar em qual PLAN.md ele e mencionado.
+
+```bash
+# Lista de REQ-IDs
+grep -oE "REQ-[A-Z]+-[0-9]+" .plano/REQUIREMENTS.md | sort -u
+
+# Para cada REQ-ID, verificar cobertura
+for req in $REQ_IDS; do
+  found=$(grep -rl "$req" .plano/fases/ 2>/dev/null | head -1)
+  [ -n "$found" ] && echo "OK: $req" || echo "MISSING: $req"
+done
+```
+
+Score parcial: cobertura = (REQs_cobertos / total_REQs)
+
+## Passo 4: Validar Sonnet-readiness
+
+Para cada PLAN.md, calcular detail score:
+
+```bash
+for plan in .plano/fases/*/*-PLAN.md; do
+  imports=$(grep -c "import \|from '" "$plan")
+  types=$(grep -c "interface \|type \|z\.\|zod" "$plan")
+  endpoints=$(grep -c "POST \|GET \|PUT \|DELETE \|/api/" "$plan")
+  sql=$(grep -c "CREATE TABLE\|migration\|ALTER" "$plan")
+  
+  score=0
+  [ $imports -gt 0 ] && score=$((score + 25))
+  [ $types -gt 0 ] && score=$((score + 25))
+  [ $endpoints -gt 0 ] && score=$((score + 25))
+  [ $sql -gt 0 ] && score=$((score + 25))
+  
+  echo "$plan: $score%"
+done
+```
+
+Score parcial: sonnet_ready_score = media de todos planos / 100
+
+## Passo 5: Validar Aprovacoes
+
+```bash
+cat .plano/governance/approvals.log
+```
+
+Verificar se ha aprovacoes de:
+- CEO (intake)
+- Architecture-supervisor (PROJECT, ROADMAP, SYSTEM-DESIGN, REQUIREMENTS)
+- Chief-architect (arquitetura global)
+- Chief-product (produto)
+- Planning-supervisor (cada PLAN)
+- Chief-engineer (planejamento cross-fase)
+
+Score parcial: aprovacoes_obtidas = (aprovacoes_obtidas / 6)
+
+## Passo 6: Validar Dependency Graph
+
+Para cada PLAN.md, extrair `depends_on` do frontmatter.
+Validar:
+- Sem dependencias circulares
+- Todos plans referenciados existem
+- Waves atribuidas (0, 1, 2, 3)
+
+Score parcial: dependency_valido = 1 se valido, 0 se nao
+
+## Passo 7: Calcular Confidence Score
+
+```
+score = (
+  artefatos_completos × 20 +
+  planos_completos × 30 +
+  cobertura_requisitos × 20 +
+  sonnet_ready_score × 15 +
+  aprovacoes_obtidas × 10 +
+  dependency_valido × 5
+)
+```
+
+## Passo 8: Detectar Inconsistencias
+
+- REQs orfaos (mapeados a fase mas nao em nenhum plano)
+- Planos orfaos (existem mas nao mapeados a REQs)
+- Conflitos entre planos
+- Decisoes contradizendo SYSTEM-DESIGN
+
+## Passo 9: Decidir
+
+```
+Se score >= 95% E zero inconsistencias criticas:
+  → READY_FOR_BUILD
+
+Se score 85-94%:
+  → READY_WITH_WARNINGS
+     (CEO vai perguntar ao dono se aceita)
+
+Se score 70-84%:
+  → NEEDS_REWORK
+     (gerar rework plan)
+
+Se score < 70%:
+  → BLOCKED
+     (escala pro CEO)
+```
+
+## Passo 10: Gerar AUDIT-PLAN.md
+
+Usar template `$HOME/.claude/up/templates/audit-plan.md`.
+
+Preencher com:
+- planning_confidence
+- recommendation
+- completude por estagio
+- artefatos missing
+- planos missing/incomplete
+- cobertura de requisitos
+- sonnet-ready scores
+- aprovacoes faltantes
+- inconsistencias
+- rework plan (se NEEDS_REWORK)
+
+## Passo 11: Atualizar Checklist
+
+Marcar items E2.5 (planning audit) como completed.
+
+## Passo 12: Retornar
+
+```markdown
+## PLANNING AUDIT COMPLETE
+
+**Planning Confidence Score:** {N}/100
+**Recomendacao:** {READY_FOR_BUILD | READY_WITH_WARNINGS | NEEDS_REWORK | BLOCKED}
+
+**Breakdown:**
+- Artefatos arquiteturais: {%}
+- Planos completos: {%}
+- Cobertura REQs: {%}
+- Sonnet-ready: {%}
+- Aprovacoes: {%}
+
+**Issues:** {N}
+**Aprovacoes faltantes:** {N}
+
+Relatorio: .plano/AUDIT-PLAN.md
+```
+
+</process>
+
+<anti_patterns>
+
+**NUNCA APROVAR SE:**
+- Algum artefato arquitetural critico esta faltando
+- Algum plano nao passou no planning-supervisor
+- Cobertura REQ < 100%
+- Dependencies tem ciclos
+- Arquivos referenciados em planos nao existem
+
+**SEMPRE BLOQUEAR SE:**
+- BRIEFING.md vazio
+- PROJECT.md sem objetivo claro
+- Algum plano com confidence < 50%
+- Arquitetura contradiz briefing
+
+</anti_patterns>
+
+<success_criteria>
+- [ ] Todos artefatos arquiteturais validados
+- [ ] Todos planos validados
+- [ ] Cobertura REQ calculada
+- [ ] Sonnet-ready scores calculados
+- [ ] Aprovacoes validadas
+- [ ] Dependency graph validado
+- [ ] Inconsistencias detectadas
+- [ ] Confidence score calculado
+- [ ] AUDIT-PLAN.md gerado
+- [ ] Checklist atualizado
+- [ ] Decisao retornada
+</success_criteria>

package/commands/build.md

@@ -0,0 +1,99 @@
+---
+name: up:build
+description: Executar projeto previamente planejado por /up:plan. Requer PLAN-READY.md. Pode rodar em runtime diferente do que planejou.
+argument-hint: ""
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - AskUserQuestion
+  - mcp__plugin_playwright_playwright__*
+---
+<objective>
+Executar projeto que foi previamente planejado.
+
+Requer `.plano/PLAN-READY.md` no diretorio atual.
+
+Conduz:
+1. Validacao light do plano (artefatos existem, planos OK)
+2. CEO local confirma execucao
+3. Build de todas as fases (com supervisao completa)
+4. Quality Gate global
+5. Delivery Audit
+6. CEO apresenta resultado
+
+**Caso de uso principal:** executar projeto planejado em outro runtime.
+Exemplo: planejou em Claude Code (`/up:plan "X"`), agora roda em OpenCode (`/up-build`).
+
+**Re-plan local permitido (max 2):** se durante execucao o supervisor descobrir
+que o plano esta inviavel, o planejador LOCAL refaz a fase. Nao volta pro runtime
+que planejou originalmente.
+
+Diferenca de /up:modo-builder:
+- modo-builder: planeja + executa em sequencia
+- build: SO executa, le PLAN-READY.md
+
+Diferenca de /up:executar-fase:
+- executar-fase: executa UMA fase
+- build: executa o PROJETO INTEIRO ate delivery
+</objective>
+
+<execution_context>
+@~/.claude/up/workflows/build.md
+@~/.claude/up/workflows/governance.md
+@~/.claude/up/workflows/dcrv.md
+@~/.claude/up/workflows/builder-e2e.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+Sem argumentos. O comando le tudo de `.plano/PLAN-READY.md`.
+</context>
+
+<process>
+**GATE 1 — Owner Profile LOCAL:**
+Verificar se `~/.claude/up/owner-profile.md` existe NESTE runtime.
+Se nao: rodar `/up:onboard` primeiro.
+
+**GATE 2 — PLAN-READY.md:**
+```bash
+if [ ! -f .plano/PLAN-READY.md ]; then
+  echo "ERRO: Este projeto nao foi planejado."
+  echo "Use /up:plan primeiro pra planejar."
+  echo "Ou /up:modo-builder pra planejar e executar de uma vez."
+  exit 1
+fi
+```
+
+**GATE 3 — Validacao Light:**
+Spot-check estrutura:
+- Artefatos arquiteturais existem (PROJECT, ROADMAP, REQUIREMENTS, SYSTEM-DESIGN)?
+- Todos planos listados em PLAN-READY.md existem no disco?
+- Frontmatter dos planos e valido?
+
+**Confiar no PLAN-READY.md.** NAO re-rodar planning-supervisor em tudo.
+
+Se algo falta: alertar e oferecer planejamento local OU abortar.
+
+**Sem model routing:** O runtime decide o modelo.
+
+**Execute the build workflow from @~/.claude/up/workflows/build.md end-to-end.**
+
+Estagios:
+1. Validacao light + CEO confirma
+2. Build (loop por fase com supervisao + DCRV + E2E + chief-engineer)
+3. Quality Gate global
+4. Delivery Audit
+5. Delivery (CEO apresenta)
+
+**Re-plan local permitido (max 2 por projeto):**
+Se execution-supervisor pedir REQUEST_REPLAN, o planejador LOCAL refaz a fase.
+Registrar em `.plano/governance/replans.log`.
+
+**A partir do CEO confirmar, ZERO interacao com usuario** (exceto alertas criticos).
+</process>

package/commands/plan.md

@@ -0,0 +1,91 @@
+---
+name: up:plan
+description: Planejamento completo de projeto. Gera PLAN-READY.md pronto pra ser executado por /up:build (mesmo runtime ou outro)
+argument-hint: "[descricao do projeto] [--execution-runtime=runtime] [--no-audit]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+  - Bash
+  - Task
+  - WebFetch
+  - WebSearch
+  - AskUserQuestion
+  - mcp__context7__*
+---
+<objective>
+Planejar projeto completo. NAO executa nada, so planeja.
+
+Conduz:
+1. Intake (CEO entrevista o dono)
+2. Arquitetura completa (Product Analyst → System Designer → Arquiteto)
+3. Planejamento exaustivo de TODAS as fases (Sonnet-ready)
+4. Planning Audit (calcula confidence score)
+5. Gera PLAN-READY.md (arquivo-flag pra /up:build)
+
+Resultado: projeto pronto pra execucao em qualquer runtime via `/up:build`.
+
+**Caso de uso principal:** planejar em Claude Code (modelo capaz pra arquitetura)
+e executar em OpenCode/Gemini (mais barato pra rodar volume).
+
+Diferenca de /up:modo-builder:
+- modo-builder: planeja + executa em sequencia, mesmo runtime
+- plan: SO planeja, para apos PLAN-READY.md
+
+Diferenca de /up:planejar-fase:
+- planejar-fase: planeja UMA fase (em projeto ja inicializado)
+- plan: planeja TODO o projeto do zero (incluindo intake e arquitetura)
+</objective>
+
+<execution_context>
+@~/.claude/up/workflows/plan.md
+@~/.claude/up/workflows/onboarding.md
+@~/.claude/up/workflows/ceo-intake.md
+@~/.claude/up/templates/plan-ready.md
+@~/.claude/up/templates/audit-plan.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+**Flags:**
+- `--execution-runtime=<runtime>` — Informa qual runtime sera usado pra executar.
+  Valores: same | claude-code | opencode | gemini-cli | any
+  Default: same
+- `--no-audit` — Pula Planning Audit (nao recomendado em producao)
+
+O restante e o briefing em texto livre.
+
+Se briefing vazio: CEO pergunta interativamente.
+
+**Deteccao automatica de modo:**
+- Codigo existente → BROWNFIELD
+- Sem codigo → GREENFIELD
+</context>
+
+<process>
+**GATE OBRIGATORIO — Owner Profile:**
+Antes de qualquer coisa, verificar se `~/.claude/up/owner-profile.md` existe.
+Se NAO existir: rodar `/up:onboard` primeiro (workflow onboarding.md).
+Sem profile, o CEO nao pode conduzir intake.
+
+**Sem model routing:** O runtime decide o modelo. NAO especificar `model=` em nenhum spawn.
+
+**Sonnet-ready obrigatorio:** Todos planos devem ser gerados em nivel maximo de detalhe.
+
+**Execute the plan workflow from @~/.claude/up/workflows/plan.md end-to-end.**
+
+Estagios:
+1. Intake (CEO entrevista o dono) — interativo
+2. Arquitetura (greenfield: pesquisa + product/system/architect | brownfield: mapear + product/system/architect)
+3. Planejamento exaustivo (TODAS as fases, planning-supervisor revisa cada uma)
+4. Planning Audit (planning-auditor calcula confidence score)
+5. PLAN-READY.md gerado
+6. CEO apresenta resumo
+
+**A partir do estagio 2, ZERO interacao com usuario.** Toda decisao e tomada autonomamente pelo CEO/chiefs/supervisores.
+
+**NAO executar nada.** Para apos gerar PLAN-READY.md.
+</process>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "up-cc",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Simplified spec-driven development for Claude Code, Gemini and OpenCode.",
   "bin": {
     "up-cc": "bin/install.js"

package/templates/audit-plan.md

@@ -0,0 +1,139 @@
+# AUDIT-PLAN.md Template
+
+Template para `.plano/AUDIT-PLAN.md` — relatorio do up-planning-auditor.
+Gerado ao final do planejamento, antes do PLAN-READY.md.
+
+Diferente do AUDIT-REPORT.md (do delivery-auditor) que audita execucao,
+este audita SOMENTE o planejamento.
+
+<template>
+
+```markdown
+---
+audited_at: ""
+auditor: up-planning-auditor
+planning_confidence: 0  # 0-100
+recommendation: PENDING | READY_FOR_BUILD | NEEDS_REWORK | BLOCKED
+---
+
+# Planning Audit Report
+
+**Planning Confidence Score:** {N}/100
+
+**Recomendacao:** {status}
+
+---
+
+## Completude por Estagio
+
+| Estagio | Items | Completed | Missing | Score |
+|---------|-------|-----------|---------|-------|
+| Intake (E1) | 5 | {N} | {N} | {%} |
+| Arquitetura (E2) | 7 | {N} | {N} | {%} |
+| Planejamento (E2.5) | {6 × phases} | {N} | {N} | {%} |
+| **TOTAL** | **{N}** | **{N}** | **{N}** | **{%}** |
+
+---
+
+## Validacao de Completude
+
+### Artefatos Arquiteturais
+
+- [ ] BRIEFING.md existe
+- [ ] OWNER.md existe
+- [ ] PROJECT.md existe e completo
+- [ ] ROADMAP.md existe e tem fases
+- [ ] REQUIREMENTS.md existe
+- [ ] SYSTEM-DESIGN.md existe e completo
+- [ ] DESIGN-TOKENS.md existe (se projeto com UI)
+- [ ] PENDING.md existe (mesmo se vazio)
+
+### Planos por Fase
+
+Para cada fase em ROADMAP.md:
+- [ ] Existe pasta `.plano/fases/XX-nome/`
+- [ ] Existe pelo menos 1 PLAN.md
+- [ ] Cada PLAN.md tem frontmatter valido
+- [ ] Cada PLAN.md tem 5-8 tarefas
+- [ ] Cada PLAN.md tem must_haves
+- [ ] Cada PLAN.md passou no planning-supervisor (PLAN-REVIEW.md existe)
+
+### Cobertura de Requisitos
+
+| REQ-ID | Mapeado a fase? | Coberto por plano? | Status |
+|--------|----------------|-------------------|--------|
+| AUTH-01 | Sim (Fase 1) | Sim (01-01-PLAN) | OK |
+| ... | | | |
+
+**Cobertura:** {covered}/{total} ({%})
+
+### Sonnet-readiness
+
+Para cada PLAN.md, checar nivel de detalhe:
+
+| Plan | Imports | Tipos | Endpoints | SQL | Score |
+|------|---------|-------|-----------|-----|-------|
+| 01-01-PLAN.md | ✓ | ✓ | ✓ | N/A | 100% |
+| 01-02-PLAN.md | ✓ | ✓ | ✓ | ✓ | 100% |
+
+**Score medio Sonnet-ready:** {%}
+
+### Dependency Graph
+
+- [ ] Todas dependencias entre planos resolvidas
+- [ ] Sem ciclos detectados
+- [ ] Waves atribuidas (0, 1, 2, 3)
+- [ ] Paralelismo maximizado onde possivel
+
+---
+
+## Aprovacoes Faltantes
+
+| Item | Esperado | Atual |
+|------|----------|-------|
+| [item] | [supervisor] APPROVE | pending/missing |
+
+---
+
+## Inconsistencias Detectadas
+
+### INC-001: [Titulo]
+**Tipo:** [conflito | gap | duplicacao]
+**Descricao:** [...]
+**Acao sugerida:** [...]
+
+---
+
+## Pendencias Conhecidas
+
+Da PENDING.md:
+- {N} blockers
+- {N} non-blockers
+
+Estas pendencias NAO bloqueiam o planejamento, mas serao revistas no delivery.
+
+---
+
+## Veredito
+
+**{READY_FOR_BUILD | NEEDS_REWORK | BLOCKED}**
+
+[Justificativa em 1-2 paragrafos]
+
+### Rework Plan (se NEEDS_REWORK)
+
+1. [acao 1]
+2. [acao 2]
+3. [acao 3]
+
+Apos rework, re-rodar auditor.
+
+### Pronto pra Build (se READY_FOR_BUILD)
+
+Proximos passos:
+1. Gerar PLAN-READY.md
+2. Apresentar ao dono via CEO
+3. Aguardar `/up:build` (mesmo runtime ou outro)
+```
+
+</template>