up-cc 0.5.2 → 0.7.0

package/workflows/build.md

@@ -0,0 +1,431 @@
+<purpose>
+Workflow `/up:build` — Execucao de projeto previamente planejado.
+
+Requer `.plano/PLAN-READY.md` (gerado por `/up:plan`).
+
+Conduz Estagios 3 (Build) + 4 (Quality Gate) + 4.5 (Delivery Audit) + 5 (Delivery).
+
+Pode executar projeto planejado em outro runtime — confia no PLAN-READY.md.
+</purpose>
+
+<core_principle>
+Este workflow assume que o projeto foi completamente planejado por `/up:plan`.
+
+Diferenca do builder:
+- Builder: planeja + executa em sequencia, no mesmo runtime
+- Build: SO executa, le PLAN-READY.md gerado anteriormente (mesmo runtime ou outro)
+
+**Sem model routing** — runtime decide o modelo.
+
+**Re-plan local permitido (max 2):**
+Se durante execucao o execution-supervisor detectar que um plano esta inviavel,
+ele pode pedir REQUEST_REPLAN. O planejador local refaz o plano daquela fase.
+NUNCA volta pro runtime que planejou originalmente.
+</core_principle>
+
+<process>
+
+## Estagio 0: GATES OBRIGATORIOS
+
+### 0.1 Owner Profile (LOCAL)
+
+```bash
+if [ ! -f ~/.claude/up/owner-profile.md ]; then
+  echo "Owner profile nao existe NESTE runtime. Rodando /up:onboard..."
+  # Delegar pro workflow onboarding.md
+fi
+```
+
+**IMPORTANTE:** O profile e do RUNTIME ATUAL, nao do runtime que planejou. Cada runtime tem seu profile.
+
+### 0.2 PLAN-READY.md Existe?
+
+```bash
+if [ ! -f .plano/PLAN-READY.md ]; then
+  echo "ERRO: Este projeto nao foi planejado."
+  echo ""
+  echo "Use /up:plan primeiro pra planejar o projeto."
+  echo "Ou /up:modo-builder pra planejar e executar de uma vez."
+  exit 1
+fi
+```
+
+### 0.3 Crash Recovery
+
+```bash
+ls .plano/LOCK.md 2>/dev/null
+```
+
+Se LOCK.md existe e `stage: build`: retomar.
+
+## Estagio V: VALIDACAO LIGHT
+
+**Confiar no PLAN-READY.md, mas spot-check estrutura.**
+
+### V.1 Parsear PLAN-READY.md
+
+```bash
+# Extrair frontmatter
+PLANNED_RUNTIME=$(grep "runtime:" .plano/PLAN-READY.md | head -1 | awk '{print $2}')
+INTENDED_RUNTIME=$(grep -A1 "intended_execution:" .plano/PLAN-READY.md | tail -1 | awk '{print $2}')
+TOTAL_PHASES=$(grep "total_phases:" .plano/PLAN-READY.md | awk '{print $2}')
+CONFIDENCE=$(grep "planning_confidence:" .plano/PLAN-READY.md | awk '{print $2}')
+```
+
+### V.2 Validacao de Compatibilidade
+
+```bash
+CURRENT_RUNTIME="claude-code"  # detectar
+[ -d ~/.config/opencode ] && CURRENT_RUNTIME="opencode"
+[ -d ~/.gemini ] && CURRENT_RUNTIME="gemini-cli"
+
+# Se intended_execution especifica um runtime e nao e o atual, alertar
+if [ "$INTENDED_RUNTIME" != "same" ] && [ "$INTENDED_RUNTIME" != "any" ] && [ "$INTENDED_RUNTIME" != "$CURRENT_RUNTIME" ]; then
+  echo "AVISO: Plano gerado pra $INTENDED_RUNTIME, voce esta em $CURRENT_RUNTIME"
+  echo "Pode haver incompatibilidades. Continuar mesmo assim?"
+  # AskUserQuestion sim/nao
+fi
+```
+
+### V.3 Validar Artefatos Esperados
+
+```bash
+[ -f .plano/PROJECT.md ] || { echo "FALTANDO: PROJECT.md"; FAIL=1; }
+[ -f .plano/ROADMAP.md ] || { echo "FALTANDO: ROADMAP.md"; FAIL=1; }
+[ -f .plano/REQUIREMENTS.md ] || { echo "FALTANDO: REQUIREMENTS.md"; FAIL=1; }
+[ -f .plano/SYSTEM-DESIGN.md ] || { echo "FALTANDO: SYSTEM-DESIGN.md"; FAIL=1; }
+```
+
+### V.4 Validar Planos Listados
+
+Pra cada plano listado em PLAN-READY.md, checar se arquivo existe:
+
+```bash
+# Extrair lista de planos do PLAN-READY.md
+PLANS=$(grep -oE "fases/[0-9]+-[a-z-]+/[0-9]+-[0-9]+-PLAN.md" .plano/PLAN-READY.md)
+
+for plan in $PLANS; do
+  if [ ! -f ".plano/$plan" ]; then
+    echo "FALTANDO: $plan"
+    FAIL=1
+  fi
+done
+```
+
+### V.5 Decidir
+
+**Se todos arquivos OK:** prosseguir.
+
+**Se algo falta:** 
+- Alertar usuario
+- Oferecer: "Posso planejar localmente?" (re-roda /up:plan)
+- Ou abortar
+
+## Estagio C: CEO CONFIRMA
+
+Spawnar CEO local:
+
+```python
+Agent(
+  subagent_type="up-project-ceo",
+  prompt="""
+    Confirmar execucao de projeto previamente planejado.
+    
+    <files_to_read>
+    - ~/.claude/up/owner-profile.md (perfil LOCAL deste runtime)
+    - .plano/BRIEFING.md (briefing original)
+    - .plano/PLAN-READY.md (resumo do planejamento)
+    - .plano/AUDIT-PLAN.md (audit do planejamento)
+    - .plano/PENDING.md
+    </files_to_read>
+    
+    Apresentar ao dono:
+    - "Detectei projeto planejado em {runtime} por {ceo_name_anterior}"
+    - Resumo: N fases, M planos
+    - Planning confidence: X/100
+    - Pendencias conhecidas
+    - "Iniciar execucao? (enter pra continuar)"
+    
+    Se dono confirmar: prosseguir.
+    Se recusar: abortar.
+  """
+)
+```
+
+## Estagio 3: BUILD (loop por fase)
+
+**Mesmo processo do builder.md secao Estagio 3, mas SEM model routing.**
+
+Para cada fase em ROADMAP.md (em ordem):
+
+### 3.1 Carregar Plano da Fase
+
+```bash
+PHASE_DIR=$(ls -d .plano/fases/{phase_number}-* 2>/dev/null)
+PLAN=$(ls "$PHASE_DIR"/*-PLAN.md | head -1)
+```
+
+### 3.2 Detectar Tipo de Plano (Specialist Routing)
+
+Ler o frontmatter do plano pra determinar qual specialist usar:
+- Frontend tasks → up-frontend-specialist
+- Backend tasks → up-backend-specialist
+- Database tasks → up-database-specialist
+- Misto → up-executor
+
+### 3.3 Spawnar Specialist
+
+```python
+Agent(
+  subagent_type="{up-specialist}",
+  prompt=f"""
+    Executar Plano da Fase {phase_number}.
+    
+    <engineering_principles_compressed>
+    1. Implementacao real, nao simulacao (zero placeholder, zero stub)
+    2. Correto, nao rapido (sem `any`, validacao com lib, queries parametrizadas)
+    3. Conectado ponta a ponta (componente → API → DB com dados fluindo)
+    4. Consistencia (grep por pattern existente antes de inventar)
+    5. Dados reais desde o primeiro momento (sem hardcode)
+    6. Cada decisao tem custo futuro (escolher solucao escalavel)
+    
+    Em duvida entre rapido e correto: sempre o correto.
+    Sob demanda: Read references/engineering-principles.md para exemplos.
+    </engineering_principles_compressed>
+    
+    <production_requirements_compressed>
+    Categorias a respeitar (71 requisitos no total):
+    - UIST (UI States): loading/error/empty/success em TODA operacao async
+    - ERR (Error handling): boundaries, try/catch, sessao expirada, 404
+    - PERF: lazy loading, code split, debounce, pagination > 20 items, cache
+    - FORM: validacao inline, mensagens especificas, autofocus, mascaras
+    - RESP: 375px funcional, touch 44x44, hamburger mobile
+    - A11Y: alt, labels, focus visible, keyboard, contraste 4.5:1
+    - SEC: rotas protegidas, CSRF, XSS, rate limit, env vars, RLS
+    - POLISH: hover, transicoes 150-300ms, design tokens
+    
+    Sob demanda: Read references/production-requirements.md para IDs especificos.
+    </production_requirements_compressed>
+    
+    <files_to_read>
+    TIER 1 — Sempre:
+    - {PLAN}
+    - .plano/STATE.md
+    - ./CLAUDE.md (se existir)
+    
+    TIER 2 — Se a slice da fase existe (v0.7.0+):
+    - .plano/fases/{phase_number}/PHASE.md (objetivo da fase)
+    - .plano/fases/{phase_number}/REQUIREMENTS-SLICE.md (REQs APENAS desta fase)
+    - .plano/DESIGN-TOKENS.md (se for frontend e existir)
+    
+    TIER 3 — Sob demanda apenas:
+    - .plano/PROJECT.md (so se precisar visao geral)
+    - .plano/SYSTEM-DESIGN.md (so se decisao de arquitetura aparecer)
+    - .plano/REQUIREMENTS.md (so se a slice nao tiver info suficiente)
+    </files_to_read>
+    
+    Implementar todas as tarefas. Commitar atomicamente.
+    Gerar SUMMARY.md.
+  """
+)
+```
+
+### 3.4 Execution Supervisor Revisa
+
+```python
+Agent(
+  subagent_type="up-execution-supervisor",
+  prompt=f"""
+    Revisar execucao da Fase {phase_number}.
+    
+    <governance_compressed>
+    DECISOES: APPROVE | REQUEST_CHANGES | REQUEST_REPLAN | ESCALATE
+    REWORK: max 3 ciclos antes de forcar approval com debito
+    NUNCA APROVAR: trabalho nao verificado, evidencia ambigua, claim sem backing,
+                   stub/placeholder, falta de wiring
+    </governance_compressed>
+    
+    <engineering_principles_compressed>
+    1. Implementacao real (zero placeholder)
+    2. Correto, nao rapido
+    3. Conectado ponta a ponta
+    4. Consistencia (seguir patterns existentes)
+    5. Dados reais
+    6. Custo futuro
+    </engineering_principles_compressed>
+    
+    <files_to_read>
+    - {PLAN}
+    - {PHASE_DIR}/*-SUMMARY.md
+    - git diff (use Bash)
+    - .plano/fases/{phase_number}/REQUIREMENTS-SLICE.md (se existir)
+    
+    Sob demanda apenas:
+    - $HOME/.claude/up/references/engineering-principles.md (exemplos)
+    - $HOME/.claude/up/references/governance-rules.md (hierarquia)
+    - $HOME/.claude/up/references/rework-limits.md (fluxos)
+    - $HOME/.claude/up/references/production-requirements.md (IDs especificos)
+    </files_to_read>
+    
+    Decisao: APPROVE | REQUEST_CHANGES | REQUEST_REPLAN | ESCALATE
+    
+    REQUEST_REPLAN: Se descobrir que o plano e fundamentalmente errado/inviavel.
+                    Max 2 re-plans por projeto.
+  """
+)
+```
+
+### 3.5 Processar Decisao do Supervisor
+
+**Se APPROVE:** prosseguir.
+
+**Se REQUEST_CHANGES:** re-spawn specialist com feedback (max 3 ciclos).
+
+**Se REQUEST_REPLAN:**
+
+```bash
+REPLAN_COUNT=$(cat .plano/governance/replans.log 2>/dev/null | wc -l)
+if [ "$REPLAN_COUNT" -ge 2 ]; then
+  echo "Max re-plans atingido. Escalando pro CEO."
+  # ESCALATE
+else
+  # Re-planejar fase localmente
+  echo "REQUEST_REPLAN aprovado. Re-planejando fase {phase_number} localmente..."
+  
+  # Spawnar planejador LOCAL
+  Agent(
+    subagent_type="up-planejador",
+    prompt=f"""
+      RE-PLAN da Fase {phase_number}.
+      
+      Plano original: {PLAN}
+      Razao do re-plan: {execution_supervisor_reason}
+      
+      Refaca o plano corrigindo o problema descoberto.
+    """
+  )
+  
+  # Salvar como -PLAN-v2.md
+  mv "$PLAN" "${PLAN%-PLAN.md}-PLAN-v1.md"
+  # novo plano vira PLAN principal
+  
+  # Registrar
+  echo "$(date -u) | phase-{phase_number} | execution-supervisor | REPLAN | reason: {reason}" >> .plano/governance/replans.log
+  
+  # Planning-supervisor revisa novo plano
+  Agent(subagent_type="up-planning-supervisor", ...)
+  
+  # Voltar pro 3.3 (re-spawn specialist)
+fi
+```
+
+**Se ESCALATE:** chief-engineer entra.
+
+### 3.6 Verificacao
+
+```python
+Agent(subagent_type="up-verificador", ...)
+Agent(subagent_type="up-verification-supervisor", ...)
+```
+
+### 3.7 E2E + DCRV
+
+Ver builder.md secao 3.1.5 (E2E) e 3.1.5.1 (DCRV).
+
+### 3.8 Chief-engineer Aprova Fase
+
+```python
+Agent(
+  subagent_type="up-chief-engineer",
+  prompt="Revisar Fase {phase_number} consolidada."
+)
+```
+
+### 3.9 Marcar Completa e Avancar
+
+## Estagio 4: QUALITY GATE GLOBAL
+
+Mesmo processo do builder.md secao Estagio 4. Sem model routing.
+
+## Estagio 4.5: DELIVERY AUDIT
+
+```python
+Agent(subagent_type="up-delivery-auditor", ...)
+```
+
+## Estagio 5: DELIVERY
+
+Mesmo processo. CEO local apresenta resultado.
+
+### 5.X Marcar Projeto Completo
+
+```bash
+# PLAN-READY.md → PROJECT-COMPLETE.md
+mv .plano/PLAN-READY.md .plano/PROJECT-COMPLETE.md
+```
+
+Adicionar ao frontmatter:
+```yaml
+status: complete
+completed_at: [timestamp]
+completed_by:
+  runtime: [current]
+  ceo_name: [local]
+final_confidence: [from audit]
+```
+
+</process>
+
+<replans>
+
+## Re-plans Locais (max 2)
+
+Quando: execution-supervisor descobre que o plano original esta inviavel.
+
+Como funciona:
+
+```
+Execution falha
+  ↓
+execution-supervisor analisa
+  ↓
+Decide: REQUEST_REPLAN
+  ↓
+Verifica replans.log < 2?
+  ├─ Sim: prosseguir
+  └─ Nao: ESCALATE pro CEO
+  ↓
+Spawnar planejador LOCAL no runtime atual
+  ↓
+Refaz plano daquela fase
+  ↓
+Salva como PLAN-v2.md (preserva v1 pra historico)
+  ↓
+Planning-supervisor LOCAL revisa
+  ↓
+Se APPROVE: voltar pro executor com novo plano
+Se REJECT: ESCALATE pro chief-engineer
+```
+
+Registro em `.plano/governance/replans.log`:
+```
+2026-04-11T15:30:00Z | phase-3 | execution-supervisor | REPLAN | cycle 1/2
+  reason: Library X discontinued, need to use Y instead
+  original_plan: 03-01-PLAN-v1.md
+  new_plan: 03-01-PLAN.md (was v2)
+```
+
+</replans>
+
+<success_criteria>
+- [ ] Owner profile LOCAL validado
+- [ ] PLAN-READY.md existe e parseado
+- [ ] Validacao light passou (artefatos + planos existem)
+- [ ] CEO confirmou execucao
+- [ ] Todas fases executadas com supervisao
+- [ ] Re-plans registrados (se houve)
+- [ ] Quality Gate global passou
+- [ ] Delivery audit aprovou
+- [ ] CEO apresentou resultado
+- [ ] PLAN-READY.md → PROJECT-COMPLETE.md
+</success_criteria>

package/workflows/builder.md

@@ -55,37 +55,25 @@ Neste modo, TODOS os agentes devem:
 7. **Quality Gate:** Incluir clone-verifier como dimensao "Fidelidade" (20% do score).
 </core_principle>
 
-<model_routing>
-## Roteamento de Modelos por Papel
+<model_handling>
+## Modelos (v0.6.0+)
 
-**REGRA OBRIGATORIA:** Ao spawnar QUALQUER agente via Task() ou Agent(), incluir o parametro `model` baseado nesta tabela. Usar os valores de $MODEL_* extraidos do builder-defaults.md (Estagio 1.1).
+**O runtime decide o modelo.** O UP nao especifica `model=opus/sonnet/haiku` em nenhum spawn de agente.
 
-| Papel | Variavel | Agentes | Default |
-|-------|----------|---------|---------|
-| **Planning** | $MODEL_PLANNING | up-arquiteto, up-product-analyst, up-system-designer, up-planejador, up-roteirista | opus |
-| **Execution** | $MODEL_EXECUTION | up-executor, up-frontend-specialist, up-backend-specialist, up-database-specialist | sonnet |
-| **Verification** | $MODEL_VERIFICATION | up-verificador, up-code-reviewer, up-blind-validator, up-requirements-validator | opus |
-| **Detection** | $MODEL_DETECTION | up-visual-critic, up-exhaustive-tester, up-api-tester | sonnet |
-| **Research** | $MODEL_RESEARCH | up-pesquisador-projeto, up-pesquisador-mercado, up-mapeador-codigo, up-sintetizador | sonnet |
-| **Quality** | $MODEL_QUALITY | up-qa-agent, up-security-reviewer, up-auditor-ux, up-auditor-performance, up-auditor-modernidade, up-sintetizador-melhorias, up-consolidador-ideias, up-devops-agent, up-technical-writer | opus |
+- Em Claude Code, os agentes usam o modelo default (Opus 4.6) ou o que o usuario configurou via `/model`.
+- Em OpenCode, cada agente usa o modelo configurado no `opencode.json`.
+- Em Gemini CLI, usa o modelo do runtime.
 
-**Exemplo de aplicacao:**
-```python
-# ANTES (sem model routing):
-Task(subagent_type="up-executor", prompt="...")
+Antes v0.5.x tinha routing por papel (planning=opus, execution=sonnet). Isso foi removido em v0.6.0 para simplicidade e portabilidade entre runtimes.
 
-# DEPOIS (com model routing):
-Task(subagent_type="up-executor", model="$MODEL_EXECUTION", prompt="...")
+**Planos sao sempre gerados em nivel detalhado (Sonnet-ready)** independente do modelo que vai executar. Assim funcionam em qualquer runtime.
 
-# Equivale a (com defaults):
-Task(subagent_type="up-executor", model="sonnet", prompt="...")
+**Ao spawnar qualquer agente:**
+```python
+Task(subagent_type="up-executor", prompt="...")
 ```
-
-**Ao spawnar qualquer agente, SEMPRE:**
-1. Identificar o papel do agente na tabela acima
-2. Usar a variavel $MODEL_* correspondente como parametro model
-3. Se a variavel nao foi definida (sem builder-defaults), usar o default da tabela
-</model_routing>
+Sem parametro `model`.
+</model_handling>
 
 <governance>
 ## Camada de Governanca (v0.5.0+)
@@ -207,23 +195,7 @@ DEFAULTS_PATH="$HOME/.claude/up/builder-defaults.md"
 
 Ler `$DEFAULTS_PATH` se existir. Se nao existir, informar: "Sem builder-defaults.md. Usando inferencia inteligente para decisoes nao especificadas. Crie ~/.claude/up/builder-defaults.md para personalizar."
 
-**Extrair configuracao de modelos:**
-
-Se builder-defaults.md existe, procurar secao "## Modelos por Papel" e extrair mapeamento:
-```
-$MODEL_PLANNING = modelo para planning (default: opus)
-$MODEL_EXECUTION = modelo para execution (default: sonnet)
-$MODEL_VERIFICATION = modelo para verification (default: opus)
-$MODEL_DETECTION = modelo para detection (default: sonnet)
-$MODEL_RESEARCH = modelo para research (default: sonnet)
-$MODEL_QUALITY = modelo para quality (default: opus)
-```
-
-Se secao nao existe: usar defaults acima (opus planeja, sonnet executa, opus verifica).
-
-**IMPORTANTE — Sonnet-ready planning:**
-Se `$MODEL_EXECUTION = sonnet`, setar flag `$SONNET_EXECUTION = true`.
-Isso ativa nivel extra de detalhe nos planos (ver planejador Sonnet-ready mode).
+**v0.6.0+: Sem extracao de modelos.** O runtime decide o modelo. Planos sao sempre Sonnet-ready (detalhe maximo).
 
 **Detectar modo automaticamente:**
 
@@ -659,7 +631,7 @@ Escrever .plano/PRODUCT-ANALYSIS.md
 Commit apos escrever.
 Retornar: ## PRODUCT ANALYSIS COMPLETE
 </output>
-", subagent_type="up-product-analyst", model="$MODEL_PLANNING", description="Analisar produto e mercado")
+", subagent_type="up-product-analyst", description="Analisar produto e mercado")
 ```
 
 Verificar retorno `## PRODUCT ANALYSIS COMPLETE`. Se falhou: registrar e continuar (System Designer usara blueprints como fallback).
@@ -708,7 +680,7 @@ Escrever .plano/SYSTEM-DESIGN.md
 Commit apos escrever.
 Retornar: ## SYSTEM DESIGN COMPLETE
 </output>
-", subagent_type="up-system-designer", model="$MODEL_PLANNING", description="Projetar sistema completo")
+", subagent_type="up-system-designer", description="Projetar sistema completo")
 ```
 
 ```
@@ -771,7 +743,7 @@ Se brownfield:
 - parallelization=true
 - Commit todos arquivos ao final
 </constraints>
-", subagent_type="up-arquiteto", model="$MODEL_PLANNING", description="Estruturar projeto executavel")
+", subagent_type="up-arquiteto", description="Estruturar projeto executavel")
 ```
 
 ### 2.7 Validar Requisitos (Quality Gate de Planejamento)
@@ -785,7 +757,7 @@ Validando requisitos (13 checks)...
 ```
 Task(
   subagent_type="up-requirements-validator",
-  model="$MODEL_VERIFICATION",
+ ,
   prompt="
     <objective>
     Validar REQUIREMENTS.md com 13 checks automaticos.
@@ -977,7 +949,7 @@ Task(prompt="
 <planning_context>
 **Fase:** {phase_number}
 **Modo:** builder (autonomo -- NAO use AskUserQuestion)
-<sonnet_execution>{$SONNET_EXECUTION}</sonnet_execution>
+**Sonnet-ready:** sempre (default em v0.6.0+)
 
 <files_to_read>
 - .plano/STATE.md (Estado do Projeto)
@@ -1019,14 +991,14 @@ Se algo falhar, corrija antes de retornar.
 Escrever PLAN.md em: .plano/fases/{phase_dir}/
 Retornar: ## PLANNING COMPLETE com resumo dos planos
 </output>
-", subagent_type="up-planejador", model="$MODEL_PLANNING", description="Planejar Fase {phase_number}")
+", subagent_type="up-planejador", description="Planejar Fase {phase_number}")
 ```
 
 Verificar retorno:
 - `## PLANNING COMPLETE` → prosseguir para quality gate do plano
 - `## PLANNING INCONCLUSIVE` → tentar novamente com mais contexto (max 2 tentativas)
 
-**Quality Gate do Plano (se $SONNET_EXECUTION = true):**
+**Quality Gate do Plano (sempre):**
 
 Antes de passar pro executor, verificar qualidade do plano rapidamente:
 ```bash
@@ -1043,7 +1015,7 @@ done
 ```
 
 Se algum plano tem detail_score < 2 e a fase tem mais de 3 tarefas:
-- Re-spawnar planejador com instrucao extra: "Plano insuficientemente detalhado para executor Sonnet. Reescrever com imports, tipos, schemas e endpoints explicitos. Ver self-check Sonnet-ready."
+- Re-spawnar planejador com instrucao extra: "Plano insuficientemente detalhado. Reescrever com imports, tipos, schemas e endpoints explicitos. Ver self-check Sonnet-ready."
 - Max 1 re-tentativa de enriquecimento
 
 ```
@@ -1091,7 +1063,7 @@ Para cada wave, spawnar agentes especializados em paralelo (se parallelization=t
 ```
 Task(
   subagent_type="{up-frontend-specialist | up-backend-specialist | up-database-specialist | up-executor}",
-  model="$MODEL_EXECUTION",
+ ,
   prompt="
     <objective>
     Executar plano {plan_number} da fase {phase_number}-{phase_name}.
@@ -1154,7 +1126,7 @@ Spawnar code reviewer:
 ```
 Task(
   subagent_type="up-code-reviewer",
-  model="$MODEL_VERIFICATION",
+ ,
   prompt="
     <objective>
     Revisar codigo da fase {phase_number} contra production-requirements e padroes de qualidade.
@@ -1211,7 +1183,7 @@ Modo builder. NAO use AskUserQuestion.
 </builder_mode>
 ",
   subagent_type="up-verificador",
-  model="$MODEL_VERIFICATION"
+ 
 )
 ```
 
@@ -1707,7 +1679,7 @@ Relatorio em .plano/ideias/RELATORIO.md
 ```
 Task(
   subagent_type="up-blind-validator",
-  model="$MODEL_VERIFICATION",
+ ,
   prompt="
     <objective>
     Validar requisitos SEM ler codigo. Apenas navegar o app via Playwright e curl.
@@ -1859,7 +1831,7 @@ Spawnar devops agent:
 ```
 Task(
   subagent_type="up-devops-agent",
-  model="$MODEL_QUALITY",
+ ,
   prompt="
     <objective>
     Gerar artefatos de producao para o projeto: Dockerfile, docker-compose, CI/CD, .env.example, seed data, scripts.
@@ -1898,7 +1870,7 @@ Spawnar technical writer:
 ```
 Task(
   subagent_type="up-technical-writer",
-  model="$MODEL_QUALITY",
+ ,
   prompt="
     <objective>
     Gerar documentacao completa: README.md, API docs, CHANGELOG.md, setup guide.
@@ -1940,7 +1912,7 @@ Spawnar security reviewer:
 ```
 Task(
   subagent_type="up-security-reviewer",
-  model="$MODEL_QUALITY",
+ ,
   prompt="
     <objective>
     Auditar codigo para vulnerabilidades de seguranca (OWASP Top 10, auth, injection, data exposure).
@@ -1978,7 +1950,7 @@ Spawnar QA agent:
 ```
 Task(
   subagent_type="up-qa-agent",
-  model="$MODEL_QUALITY",
+ ,
   prompt="
     <objective>
     Identificar gaps de cobertura de testes, escrever testes que faltam, executar todos.
@@ -2505,7 +2477,7 @@ Spawnar up-verificador (mesmo do full — verificacao real, nao shortcut):
 ```
 Task(
   subagent_type="up-verificador",
-  model="$MODEL_VERIFICATION",
+ ,
   prompt="Verificar fase {phase_number}. Diretorio: {phase_dir}. Objetivo: {goal}."
 )
 ```

package/workflows/governance.md

@@ -32,17 +32,39 @@ Spawnar o supervisor:
 ```python
 Agent(
   subagent_type="up-{supervisor_name}",
-  model="opus",
   prompt="""
     Revisar output de {operacional_name} para {context}.
     
+    <governance_compressed>
+    DECISOES:
+    - APPROVE — criterios atendidos, sem issues criticas, evidencia clara
+    - REQUEST_CHANGES — 1+ criterio falhou, feedback especifico e acionavel
+    - ESCALATE — fora do escopo, decisao arquitetural ou conflito → chief
+    
+    REWORK LIMITS:
+    - Operacional ← Supervisor: max 3 ciclos, depois forca approval com debito tecnico
+    - Supervisor ← Chief: max 2 ciclos, depois escala pro CEO
+    
+    NUNCA APROVAR SE:
+    - Trabalho nao foi de fato verificado ("parece ok")
+    - Evidencia faltando ou ambigua
+    - SUMMARY claim sem backing no codigo
+    - Stub/placeholder em vez de implementacao real
+    - Falta de wiring (componente criado mas nao conectado)
+    
+    LOG OBRIGATORIO: .plano/governance/approvals.log
+    </governance_compressed>
+    
     <files_to_read>
-    - $HOME/.claude/up/references/governance-rules.md
-    - $HOME/.claude/up/references/rework-limits.md
     - [arquivos do output do operacional]
-    - [arquivos de contexto]
+    - [arquivos de contexto da fase — preferir slices em .plano/fases/{N}/]
     </files_to_read>
     
+    Versoes COMPLETAS (so se decisao precisa de detalhe):
+    - Read $HOME/.claude/up/references/governance-rules.md
+    - Read $HOME/.claude/up/references/rework-limits.md
+    - Read $HOME/.claude/up/references/engineering-principles.md
+    
     Avaliar contra criterios objetivos.
     Retornar: APPROVE | REQUEST_CHANGES | ESCALATE
   """