up-cc 0.14.0 → 0.16.0

package/{workflows → up/workflows}/executar-plano.md

@@ -165,9 +165,78 @@ Apresentar identificacao do plano, esperar confirmacao.
 ```bash
 PLAN_START_TIME=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 PLAN_START_EPOCH=$(date +%s)
+
+# Wave 3 (v0.12+) — timeout supervisor + stuck detector
+mkdir -p .plano/runtime
+ACTIVITY_LOG=".plano/runtime/agent-activity-${PHASE:-current}.log"
+echo "${PLAN_START_TIME}|start|${PHASE:-current}" >> "$ACTIVITY_LOG"
+LAST_ACTIVITY_EPOCH=$PLAN_START_EPOCH
+
+TIMEOUT_SOFT=${UP_TIMEOUT_SOFT:-1200}   # 20m
+TIMEOUT_HARD=${UP_TIMEOUT_HARD:-1800}   # 30m
+TIMEOUT_IDLE=${UP_TIMEOUT_IDLE:-600}    # 10m
 ```
 </step>
 
+<step name="timeout_check_protocol">
+**Wave 3 — Timeout & Stuck Detection (executar entre tarefas)**
+
+Apos COMPLETAR cada tarefa do plano:
+
+1. Append activity log:
+```bash
+echo "$(date -u +%Y-%m-%dT%H:%M:%SZ)|task_complete|task_${TASK_NUMBER}" >> "$ACTIVITY_LOG"
+LAST_ACTIVITY_EPOCH=$(date +%s)
+```
+
+2. Run timeout + stuck check:
+```bash
+TIMEOUT=$(node "$HOME/.claude/up/bin/up-tools.cjs" timeout \
+  --start $PLAN_START_EPOCH \
+  --soft $TIMEOUT_SOFT \
+  --hard $TIMEOUT_HARD \
+  --idle-since $LAST_ACTIVITY_EPOCH \
+  --idle $TIMEOUT_IDLE)
+STUCK=$(node "$HOME/.claude/up/bin/up-tools.cjs" stuck-check \
+  --log "$ACTIVITY_LOG" --window 10 --threshold 3)
+```
+
+3. Decisao por status:
+
+| Status | Acao |
+|--------|------|
+| `ok` | Continuar normal |
+| `soft_warning` | Acelerar — pular tarefas opcionais, simplificar |
+| `idle_warning` | Tentar destravar; se proxima tarefa nao avanca, abortar |
+| `hard_abort` | PARAR e retornar ABORTED_TIMEOUT |
+| stuck=true | PARAR e retornar ABORTED_STUCK |
+
+4. Se hard_abort ou stuck:
+```bash
+mkdir -p .plano/governance
+echo "$(date -u +%Y-%m-%dT%H:%M:%SZ)|phase-${PHASE}|executor|ABORTED|${TIMEOUT_STATUS:-stuck}|elapsed=$(($(date +%s) - PLAN_START_EPOCH))s" >> .plano/governance/aborts.log
+
+# Salvar PARTIAL-SUMMARY.md com tarefas completas
+cat > "${PHASE_DIR}/PARTIAL-SUMMARY.md" <<'EOF'
+---
+phase: ${PHASE}
+status: aborted
+reason: ${TIMEOUT_STATUS:-stuck}
+last_completed_task: ${TASK_NUMBER}
+EOF
+```
+
+Retornar mensagem estruturada:
+```
+ABORTED: Fase {phase} por {timeout|stuck}
+Tarefas: {N}/{TOTAL} completas
+Decorrido: {elapsed}s
+Estado parcial: .plano/fases/{phase}/PARTIAL-SUMMARY.md
+```
+
+NAO continuar trabalho apos abort. Orquestrador decide proximo passo (retry com escopo reduzido, escalar pro chief, etc).
+</step>
+
 <step name="load_prompt">
 ```bash
 cat .plano/fases/XX-nome/{fase}-{plano}-PLAN.md

package/{workflows → up/workflows}/governance.md

@@ -61,9 +61,9 @@ Agent(
     </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
+    - Read $HOME/.claude/up/references/governance-rules-compressed.md
+    - Read $HOME/.claude/up/references/rework-limits-compressed.md
+    - Read $HOME/.claude/up/references/engineering-principles-compressed.md
     
     Avaliar contra criterios objetivos.
     Retornar: APPROVE | REQUEST_CHANGES | ESCALATE

package/{workflows → up/workflows}/plan.md

@@ -17,8 +17,39 @@ Diferenca do builder:
 
 Por que? Para permitir que o build rode em outro runtime (ex: planeja em Claude Code, executa em OpenCode).
 
-**Sem model routing** — runtime decide o modelo.
+**Model routing configuravel (v0.9.0+):**
+Antes de spawnar qualquer agente, resolver o modelo:
+```bash
+MODEL=$(node "$HOME/.claude/up/bin/up-tools.cjs" config resolve-model {agent-name} --raw)
+```
+Se `default`: nao passar `model=`. Se `opus/sonnet/haiku`: passar `model="{MODEL}"` no spawn.
+Isso permite que o usuario configure via `/up:configurar` quais agentes usam qual modelo.
+Sem configuracao, todos usam o modelo do runtime (comportamento v0.6.0).
+
 **Sonnet-ready obrigatorio** — todos planos em nivel maximo de detalhe.
+
+**REGRA ANTI-COLAPSO — SEPARACAO RIGIDA DE AGENTES:**
+
+O LLM tende a otimizar colapsando passos — dar ao mesmo agente tarefas de analisar + projetar,
+ou pular supervisores por parecer "overhead". Isso e PROIBIDO.
+
+**Cada passo abaixo DEVE ser um Agent() SEPARADO.**
+**NUNCA combinar dois passos em um unico spawn.**
+**NUNCA instruir um agente a fazer o trabalho de outro.**
+
+Exemplo do que NAO fazer:
+```
+# ERRADO — combina product-analyst + system-designer
+Agent(subagent_type="up-product-analyst", prompt="Analisar produto E projetar sistema...")
+
+# ERRADO — pula supervisor
+Agent(subagent_type="up-arquiteto", prompt="Estruturar e validar...")
+```
+
+**Mecanismo de enforcement: GATES verificaveis.**
+Cada supervisor DEVE escrever no `.plano/governance/approvals.log`.
+Cada GATE verifica que o log tem a entry esperada.
+Se o gate falha, NAO avance — spawne o agente faltante.
 </core_principle>
 
 <process>
@@ -95,34 +126,112 @@ fi
 
 **Brownfield:** spawnar 4 mapeadores em paralelo (ver builder.md secao similar).
 
-### 2.3 Pipeline de Arquitetura
+### 2.3 Pipeline de Arquitetura (com GATES verificaveis)
+
+**Inicializar governance:**
+```bash
+mkdir -p .plano/governance
+touch .plano/governance/approvals.log
+echo "# Governance initialized at $(date -u +%Y-%m-%dT%H:%M:%SZ)" >> .plano/governance/approvals.log
+```
 
-Spawnar em sequencia:
+Spawnar em sequencia — CADA UM e um Agent() SEPARADO:
 
 ```python
-# Product Analyst
+# PASSO 1: Product Analyst
 Agent(subagent_type="up-product-analyst", prompt="...")
+```
 
-# Product-supervisor revisa
-Agent(subagent_type="up-product-supervisor", prompt="...")
+```bash
+# GATE: PRODUCT-ANALYSIS.md existe?
+[ -f .plano/PRODUCT-ANALYSIS.md ] && echo "OK" || { echo "FALHOU: re-spawnar product-analyst"; exit 1; }
+```
 
-# System Designer
+```python
+# PASSO 2: Product-supervisor revisa
+Agent(subagent_type="up-product-supervisor", prompt="""
+  ...
+  **OUTPUT OBRIGATORIO (fazer ANTES de retornar):**
+  ```bash
+  echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) | architecture | product-supervisor | {DECISAO} | {motivo}" >> .plano/governance/approvals.log
+  ```
+""")
+```
+
+```bash
+# GATE: product-supervisor logou?
+grep -q "product-supervisor" .plano/governance/approvals.log || { echo "FALHOU: spawnar product-supervisor"; exit 1; }
+```
+
+```python
+# PASSO 3: System Designer
 Agent(subagent_type="up-system-designer", prompt="...")
+```
 
-# Architecture-supervisor revisa
-Agent(subagent_type="up-architecture-supervisor", prompt="...")
+```bash
+# GATE: SYSTEM-DESIGN.md existe?
+[ -f .plano/SYSTEM-DESIGN.md ] && echo "OK" || { echo "FALHOU: re-spawnar system-designer"; exit 1; }
+```
 
-# Arquiteto
+```python
+# PASSO 4: Architecture-supervisor revisa system design
+Agent(subagent_type="up-architecture-supervisor", prompt="""
+  ...
+  **OUTPUT OBRIGATORIO (fazer ANTES de retornar):**
+  ```bash
+  echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) | architecture | architecture-supervisor | {DECISAO} | system-design" >> .plano/governance/approvals.log
+  ```
+""")
+```
+
+```bash
+# GATE: architecture-supervisor logou para system-design?
+grep -q "architecture-supervisor.*system-design" .plano/governance/approvals.log || { echo "FALHOU: spawnar architecture-supervisor"; exit 1; }
+```
+
+```python
+# PASSO 5: Arquiteto
 Agent(subagent_type="up-arquiteto", prompt="...")
+```
 
-# Architecture-supervisor revisa
-Agent(subagent_type="up-architecture-supervisor", prompt="...")
+```bash
+# GATE: PROJECT.md + ROADMAP.md + REQUIREMENTS.md existem?
+[ -f .plano/PROJECT.md ] && [ -f .plano/ROADMAP.md ] && [ -f .plano/REQUIREMENTS.md ] && echo "OK" || { echo "FALHOU: re-spawnar arquiteto"; exit 1; }
+```
+
+```python
+# PASSO 6: Architecture-supervisor revisa artefatos do arquiteto
+Agent(subagent_type="up-architecture-supervisor", prompt="""
+  ...
+  **OUTPUT OBRIGATORIO (fazer ANTES de retornar):**
+  ```bash
+  echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) | architecture | architecture-supervisor | {DECISAO} | architect-artifacts" >> .plano/governance/approvals.log
+  ```
+""")
+```
 
-# Requirements validator
+```bash
+# GATE: architecture-supervisor logou para architect-artifacts?
+grep -q "architecture-supervisor.*architect-artifacts" .plano/governance/approvals.log || { echo "FALHOU: spawnar architecture-supervisor"; exit 1; }
+```
+
+```python
+# PASSO 7: Requirements validator
 Agent(subagent_type="up-requirements-validator", prompt="...")
 
-# Chief-architect aprova arquitetura global
-Agent(subagent_type="up-chief-architect", prompt="...")
+# PASSO 8: Chief-architect aprova arquitetura global
+Agent(subagent_type="up-chief-architect", prompt="""
+  ...
+  **OUTPUT OBRIGATORIO (fazer ANTES de retornar):**
+  ```bash
+  echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) | architecture | chief-architect | {DECISAO} | global-architecture" >> .plano/governance/approvals.log
+  ```
+""")
+```
+
+```bash
+# GATE FINAL DE ARQUITETURA: chief-architect logou?
+grep -q "chief-architect.*global-architecture" .plano/governance/approvals.log || { echo "FALHOU: spawnar chief-architect"; exit 1; }
 ```
 
 ### 2.4 Gate Pos-Arquitetura
@@ -142,10 +251,10 @@ Agent(subagent_type="up-chief-architect", prompt="...")
 PHASES=$(node "$HOME/.claude/up/bin/up-tools.cjs" roadmap list-phases)
 ```
 
-Para cada fase:
+Para cada fase — **planejador e supervisor sao SEMPRE agentes SEPARADOS:**
 
 ```python
-# Planejador (Sonnet-ready obrigatorio)
+# PASSO A: Planejador (Sonnet-ready obrigatorio)
 Agent(
   subagent_type="up-planejador",
   prompt=f"""
@@ -180,8 +289,17 @@ Agent(
     Gerar 5-8 planos com nivel maximo de detalhe.
   """
 )
+```
 
-# Planning-supervisor revisa
+```bash
+# GATE: Planos da fase existem?
+PLAN_COUNT=$(ls .plano/fases/${PHASE_DIR}/*-PLAN.md 2>/dev/null | wc -l)
+[ "$PLAN_COUNT" -eq 0 ] && echo "GATE FALHOU: Nenhum PLAN.md para fase ${phase_number}. Re-spawnar planejador." && exit 1
+echo "OK: ${PLAN_COUNT} planos gerados para fase ${phase_number}"
+```
+
+```python
+# PASSO B: Planning-supervisor revisa (SEPARADO do planejador)
 Agent(
   subagent_type="up-planning-supervisor",
   prompt=f"""
@@ -189,30 +307,88 @@ Agent(
     
     Decisao: APPROVE | REQUEST_CHANGES | ESCALATE
     Max 3 ciclos de rework.
+    
+    **OUTPUT OBRIGATORIO (fazer ANTES de retornar):**
+    ```bash
+    echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) | phase-{phase_number} | planning-supervisor | {{DECISAO}} | {{motivo}}" >> .plano/governance/approvals.log
+    ```
   """
 )
+```
 
-# Se REQUEST_CHANGES: re-spawn planejador com feedback
-# Se ESCALATE: chief-engineer entra
-# Se APPROVE: prosseguir pra proxima fase
+```bash
+# GATE: planning-supervisor logou para esta fase?
+grep -q "phase-${PHASE_NUMBER}.*planning-supervisor" .plano/governance/approvals.log || { echo "GATE FALHOU: planning-supervisor NAO rodou para fase ${PHASE_NUMBER}. Spawnar agora."; exit 1; }
 ```
 
-Apos todas fases planejadas:
+Se REQUEST_CHANGES: re-spawn planejador com feedback (max 3 ciclos).
+Se ESCALATE: chief-engineer entra.
+Se APPROVE: prosseguir pra proxima fase.
+
+**Repetir para cada fase do ROADMAP.**
+
+Apos TODAS fases planejadas:
 
 ```python
-# Chief-engineer aprova consistencia cross-fase
+# PASSO FINAL: Chief-engineer aprova consistencia cross-fase
 Agent(
   subagent_type="up-chief-engineer",
   prompt="""
     Revisar TODOS os planos gerados.
     Validar coerencia cross-fase, dependencies, waves.
     Decisao: APPROVE | REQUEST_CHANGES
+    
+    **OUTPUT OBRIGATORIO (fazer ANTES de retornar):**
+    ```bash
+    echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) | planning | chief-engineer | {DECISAO} | cross-phase-review" >> .plano/governance/approvals.log
+    ```
   """
 )
 ```
 
+```bash
+# GATE FINAL DE PLANEJAMENTO: chief-engineer logou cross-phase review?
+grep -q "chief-engineer.*cross-phase-review" .plano/governance/approvals.log || { echo "GATE FALHOU: chief-engineer NAO aprovou cross-fase. Spawnar agora."; exit 1; }
+```
+
 ## Estagio P: PLANNING AUDIT
 
+### GATE PRE-AUDIT: Verificar que TODA governanca do planejamento rodou
+
+```bash
+echo "=== GATE PRE-AUDIT: Verificando governanca completa ==="
+
+# Contar entries esperadas
+PHASES=$(node "$HOME/.claude/up/bin/up-tools.cjs" roadmap list-phases 2>/dev/null | grep -c "phase" || echo "0")
+PLAN_SUP_COUNT=$(grep -c "planning-supervisor" .plano/governance/approvals.log 2>/dev/null)
+CHIEF_ENG=$(grep -c "chief-engineer.*cross-phase" .plano/governance/approvals.log 2>/dev/null)
+CHIEF_ARCH=$(grep -c "chief-architect" .plano/governance/approvals.log 2>/dev/null)
+PROD_SUP=$(grep -c "product-supervisor" .plano/governance/approvals.log 2>/dev/null)
+ARCH_SUP=$(grep -c "architecture-supervisor" .plano/governance/approvals.log 2>/dev/null)
+
+echo "Planning-supervisor entries: ${PLAN_SUP_COUNT} (esperado: >= ${PHASES})"
+echo "Chief-engineer cross-phase: ${CHIEF_ENG} (esperado: >= 1)"
+echo "Chief-architect: ${CHIEF_ARCH} (esperado: >= 1)"
+echo "Product-supervisor: ${PROD_SUP} (esperado: >= 1)"
+echo "Architecture-supervisor: ${ARCH_SUP} (esperado: >= 1)"
+
+FAIL=false
+[ "$CHIEF_ENG" -eq 0 ] && echo "FALHA: chief-engineer NAO aprovou cross-fase" && FAIL=true
+[ "$CHIEF_ARCH" -eq 0 ] && echo "FALHA: chief-architect NAO aprovou arquitetura" && FAIL=true
+[ "$PROD_SUP" -eq 0 ] && echo "FALHA: product-supervisor NAO revisou" && FAIL=true
+[ "$ARCH_SUP" -eq 0 ] && echo "FALHA: architecture-supervisor NAO revisou" && FAIL=true
+
+if [ "$FAIL" = true ]; then
+  echo ""
+  echo "GATE PRE-AUDIT FALHOU: Voltar e spawnar os agentes faltantes."
+  exit 1
+else
+  echo "GATE PRE-AUDIT OK: Toda governanca logada."
+fi
+```
+
+### Rodar Auditor
+
 ```python
 Agent(
   subagent_type="up-planning-auditor",
@@ -228,13 +404,20 @@ Agent(
     - .plano/SYSTEM-DESIGN.md
     - .plano/PENDING.md
     - .plano/fases/*/*.md
-    - .plano/governance/approvals.log
+    - .plano/governance/approvals.log (VERIFICAR que supervisores e chiefs logaram)
     - $HOME/.claude/up/templates/audit-plan.md
     </files_to_read>
     
     Calcular Planning Confidence Score (0-100).
     Validar artefatos, planos, cobertura REQs, Sonnet-readiness, aprovacoes.
     
+    **VERIFICAR no approvals.log:**
+    - product-supervisor logou? Se nao: penalizar score
+    - architecture-supervisor logou 2x (system-design + architect-artifacts)? Se nao: penalizar
+    - planning-supervisor logou para CADA fase? Se nao: penalizar
+    - chief-architect logou? Se nao: penalizar
+    - chief-engineer logou cross-phase? Se nao: penalizar
+    
     Gerar .plano/AUDIT-PLAN.md.
     
     Decisao: READY_FOR_BUILD | READY_WITH_WARNINGS | NEEDS_REWORK | BLOCKED
@@ -376,15 +559,17 @@ NAO RECOMENDADO em producao.
 - [ ] CEO conduziu intake
 - [ ] BRIEFING, OWNER, PENDING, DESIGN-TOKENS gerados
 - [ ] Pipeline de arquitetura completo (product-analyst → system-designer → arquiteto)
-- [ ] Architecture supervisor aprovou cada artefato
-- [ ] Chief-architect aprovou arquitetura global
+- [ ] Architecture supervisor aprovou cada artefato (LOGOU em approvals.log)
+- [ ] Chief-architect aprovou arquitetura global (LOGOU em approvals.log)
 - [ ] Chief-product aprovou fit
-- [ ] TODAS fases do ROADMAP foram planejadas
-- [ ] Planning-supervisor aprovou cada plano
-- [ ] Chief-engineer aprovou cross-fase
+- [ ] TODAS fases do ROADMAP foram planejadas (PLAN.md por fase)
+- [ ] Planning-supervisor aprovou cada plano (LOGOU em approvals.log POR FASE)
+- [ ] Chief-engineer aprovou cross-fase (LOGOU em approvals.log)
+- [ ] GATE PRE-AUDIT passou (todos 5+ governance entries verificados)
 - [ ] Planning-auditor rodou e gerou AUDIT-PLAN.md
 - [ ] Planning Confidence Score calculado
 - [ ] PLAN-READY.md gerado
 - [ ] CEO apresentou resumo ao dono
 - [ ] Commit final feito
+- [ ] .plano/governance/approvals.log tem entries de TODOS supervisores e chiefs
 </success_criteria>

package/{workflows → up/workflows}/planejar-fase.md

@@ -21,23 +21,81 @@ Parse JSON: `commit_docs`, `phase_found`, `phase_dir`, `phase_number`, `phase_na
 
 ## 2. Parsear Argumentos
 
-Extrair do $ARGUMENTS: numero da fase, flags (`--pesquisar`, `--sem-pesquisa`, `--gaps`, `--auto`).
+Extrair do $ARGUMENTS: fase (numero OU descricao), flags (`--pesquisar`, `--sem-pesquisa`, `--gaps`, `--auto`).
 
-**Se sem numero da fase:** Detectar proxima fase nao planejada do roteiro.
+**Deteccao numero vs descricao:**
+- Se o argumento (sem flags) e um numero inteiro (ex: "3", "12"): tratar como numero de fase
+- Se o argumento contem letras (ex: "sistema de auth", "Adicionar pagamentos"): tratar como descricao de fase nova
+- Se vazio: detectar proxima fase nao planejada do roteiro
 
-**Se `phase_found` = false:** Validar fase existe no ROADMAP.md. Se valida, criar diretorio:
+**Se sem numero/descricao:** Detectar proxima fase nao planejada do roteiro.
+
+**Se `phase_found` = false E argumento e numero:** Validar fase existe no ROADMAP.md. Se valida, criar diretorio:
 ```bash
 mkdir -p ".plano/fases/${padded_phase}-${phase_slug}"
 ```
 
+**Se argumento e descricao:** Prosseguir para passo 3 (que tratara a criacao se necessario).
+
 ## 3. Validar Fase
 
 ```bash
 PHASE_INFO=$(node "$HOME/.claude/up/bin/up-tools.cjs" roadmap get-phase "${PHASE}")
 ```
 
-**Se `found` = false:** Erro com fases disponiveis.
-**Se `found` = true:** Extrair `phase_number`, `phase_name`, `goal`.
+**Se `found` = true:** Extrair `phase_number`, `phase_name`, `goal`. Prosseguir para passo 4.
+
+**Se `found` = false:** A fase nao existe no ROADMAP. Duas situacoes:
+
+**3a. O argumento e um NUMERO (ex: `/up:planejar-fase 5`):**
+
+Erro --- fase numerica que nao existe no roadmap indica engano do usuario.
+
+```
+ERRO: Fase {N} nao existe no roadmap.
+Fases disponiveis: [listar]
+Para adicionar fase nova: /up:planejar-fase "descricao da fase"
+```
+
+**3b. O argumento e uma DESCRICAO (ex: `/up:planejar-fase "sistema de notificacoes"`):**
+
+Perguntar se quer adicionar ao roadmap:
+
+```
+AskUserQuestion(
+  header: "Fase nao existe no roadmap",
+  question: "A fase \"{descricao}\" nao existe no roadmap. Quer adicionar e ja planejar?",
+  options: [
+    { label: "Sim, adicionar e planejar", description: "Cria a fase no ROADMAP.md e ja gera os planos" },
+    { label: "Nao", description: "Cancelar" }
+  ]
+)
+```
+
+Se "Sim": criar a fase via up-tools e continuar:
+
+```bash
+RESULT=$(node "$HOME/.claude/up/bin/up-tools.cjs" phase add "${descricao}")
+```
+
+Extrair `phase_number`, `phase_name`, `slug`, `directory` do resultado.
+Atualizar STATE.md (mesma logica do antigo adicionar-fase):
+
+```
+Em "## Contexto Acumulado" → "### Evolucao do Roadmap" adicionar:
+- Fase {N} adicionada: {descricao}
+```
+
+Re-rodar init para obter paths corretos:
+
+```bash
+INIT=$(node "$HOME/.claude/up/bin/up-tools.cjs" init planejar-fase "${phase_number}")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Prosseguir para passo 4 com a fase recem-criada.
+
+Se "Nao": sair.
 
 ## 4. Carregar CONTEXT.md
 

package/commands/adicionar-fase.md

@@ -1,33 +0,0 @@
----
-name: up:adicionar-fase
-description: Adicionar fase ao final do roadmap
-argument-hint: "<descricao>"
-allowed-tools:
-  - Read
-  - Write
-  - Edit
-  - Bash
-  - Glob
----
-<objective>
-Add a new phase to the end of the project roadmap.
-
-**Flow:** Parse description -> Call `up-tools.cjs phase add` -> Update STATE.md -> Present result
-</objective>
-
-<execution_context>
-@~/.claude/up/workflows/adicionar-fase.md
-</execution_context>
-
-<context>
-Phase description: $ARGUMENTS
-
-Adds a new phase to ROADMAP.md at the end of the existing phase list.
-</context>
-
-<process>
-1. Parse the phase description from arguments.
-2. Call `up-tools.cjs phase add` with the description.
-3. Update STATE.md to reflect the new phase.
-4. Present the result showing the new roadmap state.
-</process>

package/commands/configurar.md

@@ -1,106 +0,0 @@
----
-name: up:configurar
-description: Configurar opcoes do workflow UP para o projeto atual
-allowed-tools:
-  - Read
-  - Write
-  - Bash
-  - AskUserQuestion
----
-
-<objective>
-Configuracao interativa das opcoes do workflow UP. Atualiza .plano/config.json com preferencias do usuario.
-</objective>
-
-<process>
-
-## 1. Carregar Configuracao Atual
-
-```bash
-cat .plano/config.json 2>/dev/null || echo "{}"
-```
-
-Valores default se ausentes:
-- `modo`: "solo"
-- `paralelizacao`: true
-- `commit_docs`: true
-- `auto_advance`: false
-
-## 2. Apresentar Opcoes
-
-Usar AskUserQuestion com valores atuais pre-selecionados:
-
-```
-AskUserQuestion([
-  {
-    question: "Modo de trabalho?",
-    header: "Modo",
-    multiSelect: false,
-    options: [
-      { label: "Solo (Recomendado)", description: "Desenvolvedor unico, commits diretos" },
-      { label: "Time", description: "Multiplos desenvolvedores, branches por fase" }
-    ]
-  },
-  {
-    question: "Paralelizar agentes quando possivel?",
-    header: "Paralelizacao",
-    multiSelect: false,
-    options: [
-      { label: "Sim (Recomendado)", description: "Agentes rodam em paralelo quando independentes" },
-      { label: "Nao", description: "Agentes rodam sequencialmente" }
-    ]
-  },
-  {
-    question: "Commitar documentos de planejamento automaticamente?",
-    header: "Commit Docs",
-    multiSelect: false,
-    options: [
-      { label: "Sim (Recomendado)", description: "STATE.md, ROADMAP.md, PLANs commitados automaticamente" },
-      { label: "Nao", description: "Apenas codigo e commitado, docs ficam unstaged" }
-    ]
-  },
-  {
-    question: "Avancar pipeline automaticamente? (discutir -> planejar -> executar)",
-    header: "Auto-Advance",
-    multiSelect: false,
-    options: [
-      { label: "Nao (Recomendado)", description: "Manual /clear entre estagios" },
-      { label: "Sim", description: "Encadeia estagios via subagentes" }
-    ]
-  }
-])
-```
-
-## 3. Atualizar config.json
-
-Mapear respostas para valores:
-
-```json
-{
-  "modo": "solo" | "time",
-  "paralelizacao": true | false,
-  "commit_docs": true | false,
-  "auto_advance": true | false
-}
-```
-
-Escrever em `.plano/config.json`.
-
-## 4. Confirmar
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- UP > CONFIGURACAO ATUALIZADA
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-| Opcao          | Valor       |
-|----------------|-------------|
-| Modo           | {solo/time} |
-| Paralelizacao  | {Sim/Nao}   |
-| Commit Docs    | {Sim/Nao}   |
-| Auto-Advance   | {Sim/Nao}   |
-
-Estas opcoes se aplicam a futuros /up:planejar-fase e /up:executar-fase.
-```
-
-</process>

package/templates/config.json

@@ -1,6 +0,0 @@
-{
-  "modo": "solo",
-  "paralelizacao": true,
-  "commit_docs": true,
-  "auto_advance": false
-}