up-cc 0.5.1 → 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/bin/install.js

@@ -280,6 +280,11 @@ function convertAgentToOpencode(content) {
   converted = converted.replace(/\bTodoWrite\b/g, 'todowrite');
   converted = converted.replace(/\/up:/g, '/up-'); // OpenCode flat command structure
 
+  // Replace Task tool calls with OpenCode format
+  // Claude Code: Task(subagent_type="up-xxx", ...) / Agent(subagent_type="up-xxx", ...)
+  // OpenCode: @up-xxx or task tool with agent name
+  converted = converted.replace(/subagent_type="up-/g, 'agent="up-');
+
   const { frontmatter, body } = extractFrontmatterAndBody(converted);
   if (!frontmatter) return converted;
 
@@ -287,11 +292,17 @@ function convertAgentToOpencode(content) {
   const newLines = [];
   const tools = [];
   let inTools = false;
+  let hasMode = false;
 
   for (const line of lines) {
     const trimmed = line.trim();
 
     if (trimmed.startsWith('name:')) continue; // OpenCode uses filename
+    if (trimmed.startsWith('mode:')) {
+      hasMode = true;
+      newLines.push(line);
+      continue;
+    }
     if (trimmed.startsWith('tools:')) {
       const toolsValue = trimmed.substring(6).trim();
       if (toolsValue) {
@@ -318,6 +329,13 @@ function convertAgentToOpencode(content) {
     if (!inTools) newLines.push(line);
   }
 
+  // CRITICAL: OpenCode requires mode: subagent for agents to be invokable via Task tool
+  // Without this, agents are treated as "primary" and isolated — primary agents cannot
+  // invoke each other. All UP agents are subagents (only user-facing primary is OpenCode itself).
+  if (!hasMode) {
+    newLines.push('mode: subagent');
+  }
+
   if (tools.length > 0) {
     newLines.push('tools:');
     for (const tool of tools) {
@@ -364,6 +382,12 @@ function replacePaths(content, pathPrefix, runtime) {
   if (runtime === 'opencode') {
     content = content.replace(/\/up:/g, '/up-');
     content = content.replace(/subagent_type="general-purpose"/g, 'subagent_type="general"');
+    // OpenCode invokes subagents via Task tool with agent name (not subagent_type)
+    // Keep subagent_type for compatibility but ensure agents have mode:subagent
+    // Replace AskUserQuestion with question (OpenCode native)
+    content = content.replace(/\bAskUserQuestion\b/g, 'question');
+    content = content.replace(/\bSlashCommand\b/g, 'skill');
+    content = content.replace(/\bTodoWrite\b/g, 'todowrite');
   }
 
   return content;

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.1",
+  "version": "0.6.0",
   "description": "Simplified spec-driven development for Claude Code, Gemini and OpenCode.",
   "bin": {
     "up-cc": "bin/install.js"