up-cc 0.4.1 → 0.4.2

package/package.json

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

package/workflows/builder.md

@@ -1046,6 +1046,67 @@ Fase {X}: E2E — {passed}/{total} testes passaram [{bugs} bugs, {fixed} corrigi
 **Se nao tem UI:** Pular silenciosamente.
 **Se dev server falha:** Registrar e pular E2E (nao bloqueia).
 
+#### 3.1.5.1 Loop DCRV — Detectar, Classificar, Resolver, Verificar (Por Fase)
+
+**Apos o E2E da fase**, rodar o workflow DCRV completo.
+
+**Referencia:** `@~/.claude/up/workflows/dcrv.md`
+
+Executar com parametros:
+```
+SCOPE=phase
+PHASE_DIR={phase_dir}
+PHASE_NUMBER={phase_number}
+PORT={porta do dev server}
+MAX_CYCLES=3
+MAX_ISSUES_PER_CYCLE=15
+AUTO_FIX=true
+REGRESSION=false (smoke test e separado no passo 3.1.5.2)
+```
+
+O workflow DCRV cuida de:
+1. Detectar modo (UI, API, ambos, nenhum)
+2. Rodar detectores na ordem (Visual → API → Exhaustive)
+3. Consolidar issue board
+4. Dispatcher diagnostica e roteia para especialistas
+5. Especialistas corrigem com commits atomicos
+6. Re-verificacao das issues corrigidas
+7. Loop ate resolver ou max ciclos
+
+Issues pendentes sao salvas em `.plano/issues-carryover/` para o Quality Gate (Estagio 4).
+
+```
+Fase {X}: DCRV — {resolved}/{total} issues resolvidas [{pending} pendentes → Quality Gate]
+```
+
+#### 3.1.5.2 Smoke Test de Regressao (A partir da Fase 3)
+
+**A partir da terceira fase**, fazer smoke test rapido das paginas de fases ANTERIORES.
+Objetivo: detectar regressoes causadas por mudancas em componentes compartilhados.
+
+**NAO e exaustivo** — apenas:
+1. Navegar cada rota de fases anteriores
+2. Verificar que renderiza (nao tela branca, nao 404)
+3. Screenshot rapido
+4. Checar console por erros novos
+
+```
+Para cada fase anterior com UI:
+  Para cada rota da fase:
+    browser_navigate(url)
+    browser_console_messages(level: "error")
+    Se erro novo detectado → registrar como regressao
+```
+
+Se regressao encontrada:
+- Severidade: HIGH (algo que funcionava quebrou)
+- Corrigir imediatamente (nao carregar para Quality Gate)
+- Commit: `fix(fase-{X}): regressao em [pagina] causada por fase {Y}`
+
+```
+Smoke test regressao: {N} rotas anteriores | {OK} ok | {REGRESS} regressoes [{FIXED} corrigidas]
+```
+
 #### 3.1.6 Marcar Fase Completa
 
 ```bash
@@ -1118,16 +1179,22 @@ Voltar para 3.1.1 com a proxima fase. Sem /clear — continuar no mesmo contexto
 Executado APOS todas as fases do build completarem.
 Ciclo de avaliacao → correcao → re-avaliacao ate atingir score >= 9.0/10.
 
-**Score Composto (6 dimensoes):**
+**Score Composto (9 dimensoes):**
 
 | Dimensao | Peso | Como mede |
 |----------|------|-----------|
-| Funcionalidade | 25% | Requisitos atendidos / total (REQUIREMENTS.md) |
-| E2E | 20% | Testes passando / total (Playwright) |
-| UX | 15% | Score do UX tester (6 sub-dimensoes) |
-| Responsividade | 15% | Score do mobile-first |
-| Codigo | 15% | Score do melhorias (UX+perf+modernidade) |
-| Completude | 10% | Paginas sem erro / total (smoke test) |
+| Funcionalidade | 15% | Requisitos atendidos / total (REQUIREMENTS.md) |
+| Blind Validation | 15% | Score do BLIND-VALIDATION.md |
+| Visual Quality | 12% | Score do up-visual-critic (VISUAL-REPORT.md) |
+| Exhaustive | 10% | Pass rate do up-exhaustive-tester (EXHAUSTIVE-REPORT.md) |
+| API Robustez | 8% | Pass rate do up-api-tester (API-REPORT.md) |
+| E2E | 10% | Testes passando / total (Playwright) |
+| UX | 10% | Score do UX tester (6 sub-dimensoes) |
+| Responsividade | 10% | Score do mobile-first |
+| Codigo | 10% | Score do code reviewer + melhorias |
+
+**Nota:** Se projeto nao tem UI, redistribuir pesos de Visual/Exhaustive/UX/Responsividade para API/Funcionalidade/Codigo.
+**Nota:** Se projeto nao tem API, redistribuir peso de API para outros.
 
 **Limites de seguranca:**
 - Max 5 ciclos de refinamento
@@ -1445,24 +1512,35 @@ Blind Validation: {score}% | {passed} PASS | {failed} FAIL | {partial} PARTIAL
 Agregar scores de todos os avaliadores:
 
 ```
-Funcionalidade (20%): requisitos [x] / total no REQUIREMENTS.md → 0-10
-Blind Valid. (20%):   score do BLIND-VALIDATION.md → 0-10
-E2E (15%):            testes passaram / total no E2E mais recente → 0-10
+Funcionalidade (15%): requisitos [x] / total no REQUIREMENTS.md → 0-10
+Blind Valid. (15%):   score do BLIND-VALIDATION.md → 0-10
+Visual (12%):         score do VISUAL-REPORT.md → 0-10
+Exhaustive (10%):     pass rate do EXHAUSTIVE-REPORT.md → 0-10
+API (8%):             pass rate do API-REPORT.md → 0-10
+E2E (10%):            testes passaram / total no E2E mais recente → 0-10
 UX (10%):             score do UX-REPORT.md → 0-10
 Responsividade (10%): score do MOBILE-REPORT.md → 0-10
-Codigo (15%):         (10 - problemas_criticos) do RELATORIO.md melhorias → 0-10
-Completude (10%):     rotas sem erro / total no smoke test → 0-10
+Codigo (10%):         score do CODE-REVIEW + melhorias → 0-10
 
 **Modo normal:**
-Score = (func × 0.20) + (blind × 0.20) + (e2e × 0.15) + (ux × 0.10) + (resp × 0.10) + (cod × 0.15) + (comp × 0.10)
+Score = (func × 0.15) + (blind × 0.15) + (visual × 0.12) + (exhaustive × 0.10) + (api × 0.08) + (e2e × 0.10) + (ux × 0.10) + (resp × 0.10) + (cod × 0.10)
 
 **Modo clone (builder_type: "clone"):**
-Score = (func × 0.15) + (fidelidade × 0.20) + (blind × 0.15) + (e2e × 0.10) + (ux × 0.10) + (resp × 0.10) + (cod × 0.10) + (comp × 0.10)
+Score = (func × 0.10) + (fidelidade × 0.15) + (blind × 0.10) + (visual × 0.15) + (exhaustive × 0.10) + (api × 0.05) + (e2e × 0.10) + (ux × 0.05) + (resp × 0.10) + (cod × 0.10)
 
 A dimensao "Fidelidade" usa o up-clone-verifier: compara features (funcional) + visual contra original.
 ```
 
-**Se algum avaliador nao rodou** (ex: sem UI, sem E2E): redistribuir peso proporcionalmente entre os que rodaram.
+**Se algum avaliador nao rodou** (ex: sem UI, sem E2E, sem API): redistribuir peso proporcionalmente entre os que rodaram.
+
+**Issues Carryover das Fases:**
+
+Antes de iniciar o Quality Gate, carregar issues pendentes do loop DCRV por fase:
+```bash
+ls .plano/issues-carryover/*.json 2>/dev/null
+```
+Estas issues ja foram detectadas e tentadas — se ainda existem, sao as mais dificeis.
+Incluir no board de issues do Quality Gate com flag `carryover: true`.
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -1471,12 +1549,15 @@ A dimensao "Fidelidade" usa o up-clone-verifier: compara features (funcional) +
 
 | Dimensao | Score | Peso | Contribuicao |
 |----------|-------|------|-------------|
-| Funcionalidade | [N]/10 | 25% | [X] |
-| E2E | [N]/10 | 20% | [X] |
-| UX | [N]/10 | 15% | [X] |
-| Responsividade | [N]/10 | 15% | [X] |
-| Codigo | [N]/10 | 15% | [X] |
-| Completude | [N]/10 | 10% | [X] |
+| Funcionalidade | [N]/10 | 15% | [X] |
+| Blind Validation | [N]/10 | 15% | [X] |
+| Visual Quality | [N]/10 | 12% | [X] |
+| Exhaustive | [N]/10 | 10% | [X] |
+| API Robustez | [N]/10 | 8% | [X] |
+| E2E | [N]/10 | 10% | [X] |
+| UX | [N]/10 | 10% | [X] |
+| Responsividade | [N]/10 | 10% | [X] |
+| Codigo | [N]/10 | 10% | [X] |
 | **TOTAL** | **[SCORE]/10** | | |
 ```
 
@@ -1497,13 +1578,28 @@ Identificar top gaps (dimensoes com menor score):
    - Extrair issues nao corrigidas / requisitos pendentes
    - Priorizar por impacto no score
 
-**Implementar correcoes:**
+**Rodar 3 detectores no projeto INTEIRO (nao apenas por fase):**
+
+Ordem: Visual Critic → API Tester → Exhaustive Tester
+
+Cada detector roda em TODAS as paginas/rotas, detectando:
+- Issues novas (nao encontradas no DCRV por fase)
+- Regressoes cross-fase (inconsistencia entre paginas de fases diferentes)
+- Issues carryover (pendentes das fases) — re-verificar se ainda existem
+
+**Implementar correcoes via Dispatcher (mesmo protocolo do DCRV por fase):**
+- Issues visuais (VIS-*): diagnosticar → up-frontend-specialist
+- Issues de interacao (INT-*): diagnosticar → up-frontend-specialist ou up-backend-specialist
+- Issues de API (API-*): diagnosticar → up-backend-specialist ou up-database-specialist
 - Issues de codigo: planejar mini-fase → executar → commit
 - Issues de UX: aplicar fixes (mesmo processo do UX tester)
 - Issues de responsividade: aplicar fixes (mesmo processo do mobile-first)
 - Requisitos pendentes: planejar mini-fase → executar
 - Issues de E2E: corrigir bugs (max 5 tentativas)
 
+**Cap de issues por ciclo: max 20** (mais generoso que o DCRV por fase).
+Prioridade: critical > high > medium. Low nunca entra.
+
 Apos implementar:
 
 ```
@@ -2218,6 +2314,9 @@ Com 1M de contexto, a maioria dos projetos cabe sem /clear. Mas monitore:
 - [ ] Estagio 3: Todas as fases verificadas
 - [ ] Estagio 3: Fases com UI testadas via Playwright (E2E-RESULTS.md)
 - [ ] Estagio 3: Bugs E2E corrigidos (quando possivel)
+- [ ] Estagio 3: DCRV por fase executado (Visual Critic + Exhaustive Tester + API Tester)
+- [ ] Estagio 3: Issues DCRV corrigidas via dispatcher (max 3 ciclos por fase)
+- [ ] Estagio 3: Smoke test de regressao em fases anteriores (a partir da fase 3)
 - [ ] Estagio 3: Reassessment apos cada fase (roadmap re-avaliado)
 - [ ] Estagio 3: Commits atomicos por tarefa
 - [ ] Estagio 3: LOCK.md atualizado a cada transicao de estado
@@ -2229,7 +2328,11 @@ Com 1M de contexto, a maioria dos projetos cabe sem /clear. Mas monitore:
 - [ ] Estagio 4: UX-REPORT.md gerado com scores e screenshots
 - [ ] Estagio 4: Mobile First executado (responsividade verificada em 3 viewports)
 - [ ] Estagio 4: MOBILE-REPORT.md gerado com score e screenshots comparativos
-- [ ] Estagio 4: Score composto calculado (6 dimensoes)
+- [ ] Estagio 4: Visual Critic global executado (VISUAL-REPORT.md)
+- [ ] Estagio 4: Exhaustive Tester global executado (EXHAUSTIVE-REPORT.md)
+- [ ] Estagio 4: API Tester global executado (API-REPORT.md)
+- [ ] Estagio 4: Issues carryover das fases processadas
+- [ ] Estagio 4: Score composto calculado (9 dimensoes)
 - [ ] Estagio 4: Quality gate loop executado (ate score >= 9.0 ou max 5 ciclos)
 - [ ] Estagio 4: DevOps artifacts gerados (Dockerfile, CI/CD, .env.example, seed)
 - [ ] Estagio 4: Documentacao gerada (README, CHANGELOG, API docs)

package/workflows/dcrv.md

@@ -0,0 +1,421 @@
+<purpose>
+Workflow DCRV (Detectar → Classificar → Resolver → Verificar) — loop de qualidade reutilizavel.
+
+Roda 3 detectores (Visual Critic, Exhaustive Tester, API Tester), consolida issues, despacha para especialistas corrigirem, e re-verifica. Loop ate resolver ou atingir max ciclos.
+
+**Modos de uso:**
+- **Por fase (builder):** Testa apenas paginas/rotas da fase recem-executada
+- **Global (quality gate):** Testa TODAS as paginas/rotas do projeto
+- **Standalone:** Chamado por /up:executar-fase, /up:rapido, /up:ux-tester, /up:verificar-trabalho
+- **Light (1 ciclo):** Roda detectores + reporta, sem loop de correcao
+
+**Parametros esperados no prompt:**
+- `$SCOPE`: "phase" | "global" | "light"
+- `$PHASE_DIR`: diretorio da fase (se scope=phase)
+- `$PHASE_NUMBER`: numero da fase (se scope=phase)
+- `$ROUTES`: lista de rotas a testar (se vazio, descobre automaticamente)
+- `$PORT`: porta do dev server (default: 3000)
+- `$MAX_CYCLES`: max ciclos de correcao (default: 3 para phase, 5 para global, 1 para light)
+- `$MAX_ISSUES_PER_CYCLE`: max issues para corrigir por ciclo (default: 15 para phase, 20 para global)
+- `$AUTO_FIX`: true | false (se false, apenas reporta sem corrigir)
+</purpose>
+
+<process>
+
+## Passo 0: Setup
+
+### 0.1 Detectar o que testar
+
+```bash
+# Dev server rodando?
+curl -s http://localhost:${PORT:-3000} > /dev/null 2>&1
+if [ $? -ne 0 ]; then
+  echo "DEV_SERVER_DOWN"
+fi
+```
+
+Se dev server nao esta rodando: subir automaticamente.
+```bash
+if [ -f package.json ]; then
+  npm run dev > /tmp/up-dcrv-server.log 2>&1 &
+  DCRV_DEV_PID=$!
+  for i in $(seq 1 30); do
+    curl -s http://localhost:${PORT:-3000} > /dev/null 2>&1 && break
+    sleep 1
+  done
+fi
+```
+
+### 0.2 Descobrir rotas (se $ROUTES vazio)
+
+**Se scope=phase:** Ler SUMMARY da fase para extrair rotas criadas/modificadas.
+```bash
+cat "$PHASE_DIR"/*-SUMMARY.md 2>/dev/null
+```
+
+**Se scope=global ou standalone:** Descobrir todas as rotas.
+```bash
+find app -name "page.tsx" -o -name "page.ts" 2>/dev/null | head -30
+find pages -name "*.tsx" -o -name "*.ts" 2>/dev/null | grep -v "_app\|_document\|api/" | head -30
+```
+
+**Descobrir rotas API:**
+```bash
+find app -path "*/api/*" -name "route.ts" 2>/dev/null
+find pages/api -name "*.ts" -o -name "*.js" 2>/dev/null
+grep -rn "app\.\(get\|post\|put\|patch\|delete\)" src/ --include="*.ts" --include="*.js" 2>/dev/null | head -20
+```
+
+### 0.3 Classificar projeto
+
+```
+HAS_UI = rotas de pagina encontradas?
+HAS_API = rotas de API encontradas?
+```
+
+| Projeto | Detectores |
+|---------|-----------|
+| UI + API | Visual Critic → API Tester → Exhaustive Tester (todos) |
+| UI only | Visual Critic → Exhaustive Tester (pular API) |
+| API only | API Tester com profundidade extra (pular visual + exhaustive) |
+| Infra/schema | Pular DCRV (nada para testar via browser/curl) |
+
+### 0.4 Carregar referencia visual
+
+```bash
+cat .plano/DESIGN-TOKENS.md 2>/dev/null
+```
+
+Se nao existe: visual critic vai inferir do codebase (e registrar ausencia como issue leve).
+
+### 0.5 Definir output dir
+
+```bash
+if [ "$SCOPE" = "phase" ]; then
+  DCRV_DIR="$PHASE_DIR/dcrv"
+elif [ "$SCOPE" = "global" ]; then
+  DCRV_DIR=".plano/dcrv"
+else
+  DCRV_DIR=".plano/dcrv"
+fi
+mkdir -p "$DCRV_DIR"
+```
+
+## Passo 1: Detectar (Rodar Detectores)
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DCRV > DETECTANDO — CICLO {CYCLE}/{MAX_CYCLES}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+**Ordem obrigatoria: Visual → API → Exhaustive**
+(Visual so observa, API usa curl, Exhaustive clica em tudo — minimiza interferencia)
+
+### 1.1 Visual Critic (se HAS_UI)
+
+```python
+Agent(
+  subagent_type="up-visual-critic",
+  prompt="""
+    Avaliar qualidade visual.
+    
+    <files_to_read>
+    - .plano/DESIGN-TOKENS.md (referencia visual, se existe)
+    </files_to_read>
+    
+    Paginas a testar: {$ROUTES_UI}
+    Dev server: http://localhost:{$PORT}
+    
+    Salvar relatorio em: {$DCRV_DIR}/VISUAL-REPORT.md
+    Salvar issues em: {$DCRV_DIR}/VISUAL-ISSUES.json
+  """
+)
+```
+
+### 1.2 API Tester (se HAS_API)
+
+```python
+Agent(
+  subagent_type="up-api-tester",
+  prompt="""
+    Testar robustez das rotas API.
+    
+    Rotas a testar: {$ROUTES_API}
+    Dev server: http://localhost:{$PORT}
+    
+    Salvar relatorio em: {$DCRV_DIR}/API-REPORT.md
+    Salvar issues em: {$DCRV_DIR}/API-ISSUES.json
+  """
+)
+```
+
+### 1.3 Exhaustive Tester (se HAS_UI)
+
+```python
+Agent(
+  subagent_type="up-exhaustive-tester",
+  prompt="""
+    Testar CADA elemento interativo.
+    
+    Paginas a testar: {$ROUTES_UI}
+    Dev server: http://localhost:{$PORT}
+    Sem limite de elementos — testar TODOS.
+    
+    Salvar relatorio em: {$DCRV_DIR}/EXHAUSTIVE-REPORT.md
+    Salvar issues em: {$DCRV_DIR}/EXHAUSTIVE-ISSUES.json
+  """
+)
+```
+
+## Passo 2: Classificar (Consolidar Issue Board)
+
+Ler os JSONs de issues dos detectores que rodaram.
+
+### 2.1 Deduplicar
+
+Se visual e exhaustive reportaram o mesmo elemento/pagina: manter a issue mais detalhada.
+Criterio: mesmo `page` + mesmo `element` (por texto ou ref) = duplicata.
+
+### 2.2 Classificar por severidade
+
+| Severidade | Criterio |
+|-----------|----------|
+| critical | Tela branca, crash, auth bypass, perda de dados, app inacessivel |
+| high | Funcionalidade principal quebrada, 500 em input basico, botao principal sem efeito |
+| medium | Inconsistencia visual, validacao faltando, feedback ausente |
+| low | Cosmetico, melhoria de polish, mensagem generica |
+
+### 2.3 Priorizar para correcao
+
+Cap por ciclo: $MAX_ISSUES_PER_CYCLE (default: 15 phase, 20 global)
+Prioridade: critical (todas) > high (ate cap) > medium (se sobrar) > low (NUNCA no loop)
+
+### 2.4 Gerar ISSUE-BOARD.md
+
+```markdown
+---
+cycle: {CYCLE}
+timestamp: {now}
+total: {N}
+critical: {N}
+high: {N}
+medium: {N}
+low: {N}
+to_fix: {N}
+deferred: {N}
+---
+
+# DCRV Issue Board — Ciclo {CYCLE}
+
+## Issues para Correcao (max {MAX_ISSUES_PER_CYCLE})
+
+| ID | Sev | Tipo | Pagina/Rota | Titulo | Detector |
+|----|-----|------|-------------|--------|----------|
+| VIS-001 | high | visual | /dashboard | Cards com padding inconsistente | visual-critic |
+| INT-003 | high | interaction | /dashboard | Botao Exportar sem efeito | exhaustive |
+| API-007 | critical | api | POST /api/users | Aceita amount negativo | api-tester |
+
+## Issues Deferidas (low)
+
+| ID | Sev | Tipo | Pagina/Rota | Titulo |
+|----|-----|------|-------------|--------|
+| VIS-012 | low | visual | /settings | Poderia ter mais breathing room |
+```
+
+Escrever em `{$DCRV_DIR}/ISSUE-BOARD.md`.
+
+**Se $AUTO_FIX = false:** Parar aqui. Retornar relatorio sem corrigir.
+
+**Se zero issues para correcao:** Pular para Passo 5 (score perfeito).
+
+## Passo 3: Resolver (Dispatcher + Especialistas)
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ DCRV > CORRIGINDO — {N} issues — CICLO {CYCLE}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### 3.1 Diagnosticar e Rotear
+
+Para cada issue a corrigir, o orquestrador FAZ diagnostico rapido:
+
+**Issues visuais (VIS-*):**
+```bash
+# Encontrar componente da pagina
+grep -rn "[rota_ou_componente]" src/ --include="*.tsx" --include="*.ts" | head -5
+```
+→ Rotear para `up-frontend-specialist`
+
+**Issues de interacao (INT-*):**
+```bash
+# Verificar se handler existe
+grep -rn "onClick\|onSubmit\|onChange" [arquivo_do_componente] | head -10
+```
+- Handler existe e chama API? → Verificar se API funciona
+  - API falha: `up-backend-specialist`
+  - API OK, handler bugado: `up-frontend-specialist`
+- Handler nao existe: `up-frontend-specialist`
+- Handler vazio (`() => {}`): `up-frontend-specialist`
+
+**Issues de API (API-*):**
+- Validacao faltando: `up-backend-specialist`
+- Schema/dados errados: `up-database-specialist`
+- Auth bypass: `up-backend-specialist`
+- 500 crash: `up-backend-specialist`
+
+### 3.2 Spawnar Especialistas
+
+Agrupar issues por especialista para eficiencia (1 spawn com multiplas issues em vez de 1 spawn por issue):
+
+```python
+Agent(
+  subagent_type="up-frontend-specialist",
+  prompt="""
+    Corrigir as seguintes issues de qualidade:
+    
+    1. {VIS-001}: {titulo} — {descricao} — Fix: {suggested_fix}
+       Arquivo: {path} | Screenshot: {evidence}
+    
+    2. {INT-003}: {titulo} — {descricao} — Fix: {suggested_fix}
+       Arquivo: {path}
+    
+    Para cada issue:
+    - Corrigir o problema
+    - Commitar: fix({scope}): {issue_id} — {titulo}
+    
+    NAO criar SUMMARY.md. Apenas corrigir e commitar.
+  """
+)
+```
+
+### 3.3 Reportar progresso
+
+```
+DCRV Ciclo {CYCLE}: {resolved}/{to_fix} issues resolvidas
+  ✓ VIS-001: Cards com padding → unificado para 16px
+  ✓ INT-003: Botao Exportar → handler conectado a API
+  ✗ API-007: Amount negativo → 2 tentativas, nao corrigido
+```
+
+## Passo 4: Verificar (Re-rodar Detectores)
+
+Re-rodar APENAS os detectores relevantes, APENAS nas issues que foram corrigidas:
+
+- Issues VIS-* corrigidas → re-rodar visual critic na pagina afetada
+- Issues INT-* corrigidas → re-rodar exhaustive tester na pagina afetada
+- Issues API-* corrigidas → re-rodar api tester na rota afetada
+
+**Criterio de saida:**
+- Todas issues critical/high corrigidas → FIM (sucesso)
+- $MAX_CYCLES atingido → FIM (log pendentes)
+- Issues nao diminuiram entre ciclos → FIM (stagnation)
+
+**Se mais ciclos:** Voltar para Passo 1 com issues pendentes.
+
+**Se FIM:** Continuar para Passo 5.
+
+## Passo 5: Gerar Relatorio Final
+
+Escrever `{$DCRV_DIR}/DCRV-REPORT.md`:
+
+```markdown
+---
+scope: {phase | global | light}
+completed: {timestamp}
+cycles: {N}
+total_issues: {N}
+resolved: {N}
+pending: {N}
+deferred_low: {N}
+visual_score: {N}/10
+exhaustive_pass_rate: {N}%
+api_pass_rate: {N}%
+---
+
+# DCRV Report
+
+**Scope:** {scope}
+**Ciclos:** {cycles_run}/{max_cycles}
+**Issues:** {resolved} resolvidas | {pending} pendentes | {deferred} deferidas
+
+## Resumo por Detector
+
+| Detector | Issues | Resolvidas | Pendentes | Score |
+|----------|--------|-----------|-----------|-------|
+| Visual Critic | {N} | {N} | {N} | {N}/10 |
+| Exhaustive Tester | {N} | {N} | {N} | {N}% pass |
+| API Tester | {N} | {N} | {N} | {N}% pass |
+
+## Issues Resolvidas
+
+| ID | Titulo | Especialista | Commit |
+|----|--------|-------------|--------|
+| VIS-001 | Cards padding | frontend | abc123 |
+
+## Issues Pendentes
+
+| ID | Sev | Titulo | Motivo |
+|----|-----|--------|--------|
+| API-007 | critical | Amount negativo | 2 tentativas, nao corrigido |
+
+## Issues Deferidas (Low)
+
+[Lista para referencia futura]
+```
+
+## Passo 6: Retornar
+
+```markdown
+## DCRV COMPLETE
+
+**Scope:** {scope}
+**Ciclos:** {cycles}/{max}
+**Issues:** {resolved}/{total} resolvidas | {pending} pendentes
+**Scores:**
+- Visual: {N}/10
+- Interacao: {N}% pass rate
+- API: {N}% pass rate
+
+Relatorio: {$DCRV_DIR}/DCRV-REPORT.md
+Issues pendentes: {$DCRV_DIR}/ISSUE-BOARD.md
+```
+
+Se scope=phase e tem issues pendentes:
+```bash
+# Salvar para carryover ao Quality Gate
+mkdir -p .plano/issues-carryover
+cp "$DCRV_DIR/ISSUE-BOARD.md" ".plano/issues-carryover/phase-${PHASE_NUMBER}.md"
+```
+
+</process>
+
+<smoke_regression>
+## Smoke Test de Regressao (Opcional — ativado por $REGRESSION=true)
+
+Rodar ANTES dos detectores. Navega paginas de fases anteriores para detectar regressoes.
+
+```
+Para cada fase anterior com UI (< fase atual):
+  Para cada rota da fase:
+    browser_navigate(url)
+    browser_console_messages(level: "error")
+    browser_take_screenshot(filename: "{$DCRV_DIR}/regression/fase-{N}-{rota}.png")
+    Se erro novo: registrar como regressao (severidade HIGH)
+```
+
+Regressoes entram no issue board com prioridade maxima (corrigir antes de issues novas).
+</smoke_regression>
+
+<success_criteria>
+- [ ] Projeto classificado (UI, API, ambos, nenhum)
+- [ ] Detectores relevantes executados na ordem correta
+- [ ] Issues deduplicadas e classificadas por severidade
+- [ ] ISSUE-BOARD.md gerado
+- [ ] Dispatcher diagnosticou e roteou corretamente (se auto_fix)
+- [ ] Especialistas corrigiram issues com commits atomicos (se auto_fix)
+- [ ] Re-verificacao executada nas issues corrigidas (se auto_fix)
+- [ ] DCRV-REPORT.md gerado com metricas
+- [ ] Issues pendentes salvas para carryover (se scope=phase)
+</success_criteria>

package/workflows/executar-fase.md

@@ -199,11 +199,66 @@ grep "^status:" "$PHASE_DIR"/*-VERIFICATION.md | cut -d: -f2 | tr -d ' '
 
 | Status | Acao |
 |--------|------|
-| `passed` | -> update_roadmap |
-| `human_needed` | **Se $BUILDER_MODE:** Considerar PASSED, registrar para revisao final no DELIVERY.md. **Se modo normal:** Apresentar itens para teste humano, obter aprovacao. |
+| `passed` | -> deep_quality_check |
+| `human_needed` | **Se $BUILDER_MODE:** Considerar PASSED, registrar para revisao final no DELIVERY.md. **Se modo normal:** Apresentar itens para teste humano, obter aprovacao. Depois -> deep_quality_check |
 | `gaps_found` | Apresentar resumo de lacunas, oferecer `/up:planejar-fase {fase} --gaps` |
 </step>
 
+<step name="deep_quality_check">
+**Verificacao profunda via DCRV (Detectar → Classificar → Resolver → Verificar)**
+
+**Se $BUILDER_MODE = true:**
+Rodar DCRV automaticamente (o builder controla isso via builder.md). Pular para update_roadmap.
+
+**Se modo normal (interativo):**
+
+Detectar se fase tem UI ou API:
+```bash
+# Checar se fase criou/modificou UI
+UI_FILES=$(grep -l "page.tsx\|component\|\.css\|\.tsx" "$PHASE_DIR"/*-SUMMARY.md 2>/dev/null | wc -l)
+# Checar se fase criou/modificou API
+API_FILES=$(grep -l "route.ts\|api/\|endpoint\|handler" "$PHASE_DIR"/*-SUMMARY.md 2>/dev/null | wc -l)
+```
+
+Se fase tem UI ou API:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ UP > VERIFICACAO PROFUNDA DISPONIVEL
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+A fase passou na verificacao de codigo. Quer rodar verificacao profunda?
+
+Isso testa:
+- Visual: alinhamento, consistencia, design tokens
+- Interacao: clica em CADA botao/link/elemento
+- API: testa cada endpoint com payloads validos e invalidos
+
+Opcoes:
+1. Rodar verificacao profunda (recomendado)
+2. Rodar apenas relatorio (sem corrigir)
+3. Pular e continuar
+```
+
+**Se usuario escolhe 1:**
+Executar workflow DCRV com scope=phase, auto_fix=true:
+```
+Referencia: @~/.claude/up/workflows/dcrv.md
+SCOPE=phase, PHASE_DIR={phase_dir}, PHASE_NUMBER={phase_number}, MAX_CYCLES=3, AUTO_FIX=true
+```
+
+**Se usuario escolhe 2:**
+Executar workflow DCRV com scope=light, auto_fix=false:
+```
+SCOPE=light, AUTO_FIX=false
+```
+
+**Se usuario escolhe 3:**
+Pular silenciosamente.
+
+Apos DCRV (se rodou): -> update_roadmap
+</step>
+
 <step name="update_roadmap">
 **Marcar fase completa e atualizar todos arquivos de rastreamento:**
 

package/workflows/rapido.md

@@ -81,7 +81,7 @@ Task(
 - Criar UM UNICO plano com 1-3 tarefas focadas
 - Tarefas rapidas devem ser atomicas e autocontidas
 - Sem fase de pesquisa
-- Alvo ~30% uso de contexto (simples, focado)
+- Alvo ~10% uso de contexto (simples, focado)
 </constraints>
 
 <output>
@@ -131,6 +131,34 @@ Apos executor retornar:
 
 ---
 
+**Passo 5.5: DCRV Light (se criou UI ou API)**
+
+Detectar se tarefa criou/modificou UI ou API:
+```bash
+# Checar SUMMARY por arquivos de UI/API
+UI_MATCH=$(grep -c "page.tsx\|component\|\.css\|\.tsx" "${QUICK_DIR}/${next_num}-SUMMARY.md" 2>/dev/null)
+API_MATCH=$(grep -c "route.ts\|api/\|endpoint\|handler" "${QUICK_DIR}/${next_num}-SUMMARY.md" 2>/dev/null)
+```
+
+**Se UI_MATCH > 0 ou API_MATCH > 0:**
+
+Rodar DCRV light (1 ciclo, apenas relatorio + correcao rapida):
+
+```
+Referencia: @~/.claude/up/workflows/dcrv.md
+SCOPE=light, MAX_CYCLES=1, MAX_ISSUES_PER_CYCLE=10, AUTO_FIX=true
+DCRV_DIR=${QUICK_DIR}/dcrv
+```
+
+Reportar resultado brevemente:
+```
+DCRV Light: {resolved}/{total} issues corrigidas
+```
+
+**Se nenhum match:** Pular silenciosamente (tarefa nao tem UI/API).
+
+---
+
 **Passo 6: Atualizar STATE.md**
 
 **6a. Verificar se secao "Tarefas Rapidas Completadas" existe:**

package/workflows/ux-tester.md

@@ -306,9 +306,35 @@ improvements: [N]
 | Foco invisivel | [N] | [lista] |
 ```
 
+## Passo 3.5: DCRV — Detectores Automaticos
+
+Apos o relatorio UX (que avalia experiencia e percepcao), rodar detectores automaticos que pegam issues objetivas que o UX tester pode nao ver.
+
+**Referencia:** `@~/.claude/up/workflows/dcrv.md`
+
+Rodar com:
+```
+SCOPE=global (testar tudo)
+AUTO_FIX=false (apenas detectar — implementacao sera no Passo 4)
+MAX_CYCLES=1 (apenas 1 ciclo de deteccao)
+PORT={porta do dev server ja rodando}
+```
+
+Apos DCRV retornar:
+1. Ler DCRV-REPORT.md
+2. Mesclar issues do DCRV com issues do UX Review:
+   - Issues VIS-* do visual critic → adicionar na dimensao "Consistencia" do UX-REPORT
+   - Issues INT-* do exhaustive tester → adicionar na dimensao "Feedback" do UX-REPORT
+   - Issues API-* do api tester → adicionar como secao "Robustez API" do UX-REPORT
+3. Deduplicar: se UX review e DCRV encontraram o mesmo problema, manter a versao mais detalhada
+4. Atualizar scores do UX-REPORT com base nas issues adicionais
+
+Isso garante que o relatorio UX e COMPLETO — experiencia (do UX tester) + objetividade (dos detectores).
+
 ## Passo 4: Implementar Melhorias
 
 **NAO perguntar ao usuario.** Implementar TODAS as melhorias que sao seguras de aplicar.
+Isso inclui tanto issues do UX Review quanto issues do DCRV mescladas no passo anterior.
 
 ### 4.1 Classificar Issues por Implementabilidade
 

package/workflows/verificar-trabalho.md

@@ -65,6 +65,53 @@ ls "$phase_dir"/*-SUMMARY.md 2>/dev/null
 Ler cada SUMMARY.md para extrair entregaveis testaveis.
 </step>
 
+<step name="auto_detect_issues">
+**Pre-validacao automatica antes do teste humano**
+
+Antes de pedir ao usuario para testar, rodar detectores automaticos para corrigir issues obvias.
+O humano testa um sistema ja pre-validado — nao perde tempo com botoes quebrados ou erros de console.
+
+Detectar se fase tem UI ou API:
+```bash
+UI_FILES=$(find app pages src -name "page.tsx" -o -name "*.component.tsx" 2>/dev/null | head -1)
+API_FILES=$(find app/api pages/api -name "route.ts" -o -name "*.ts" 2>/dev/null | head -1)
+```
+
+**Se tem UI ou API:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ UP > PRE-VALIDACAO AUTOMATICA
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Rodando detectores automaticos antes do teste manual...
+```
+
+Rodar DCRV light:
+```
+Referencia: @~/.claude/up/workflows/dcrv.md
+SCOPE=phase, PHASE_DIR={phase_dir}, PHASE_NUMBER={phase_number}
+MAX_CYCLES=1, AUTO_FIX=true
+```
+
+Reportar resultado:
+```
+Pre-validacao: {resolved}/{total} issues automaticas corrigidas
+Pronto para teste manual.
+```
+
+**Se DCRV encontrou issues criticas nao corrigidas:**
+Avisar o usuario antes de iniciar UAT:
+```
+Aviso: {N} issues criticas detectadas e NAO corrigidas automaticamente.
+O teste manual pode encontrar esses problemas. Considere rodar /up:planejar-fase {fase} --gaps primeiro.
+
+Continuar com teste manual mesmo assim? (sim/nao)
+```
+
+**Se nao tem UI/API:** Pular silenciosamente.
+</step>
+
 <step name="extract_tests">
 **Extrair entregaveis testaveis do SUMMARY.md:**