@luanpdd/kit-mcp 0.2.1 → 0.3.0

package/kit/framework/workflows/review.md

@@ -0,0 +1,228 @@
+<purpose>
+Revisão cruzada entre IAs — invoca CLIs externas de IA para revisar planos de fase de forma independente.
+Cada CLI recebe o mesmo prompt (contexto de PROJECT.md, planos de fase, requisitos) e
+produz feedback estruturado. Os resultados são combinados em REVIEWS.md para o planejador
+incorporar via flag --reviews.
+
+Implementa revisão adversarial: diferentes modelos de IA captam diferentes pontos cegos.
+Um plano que sobrevive à revisão de 2-3 sistemas de IA independentes é mais robusto.
+</purpose>
+
+<process>
+
+<step name="detect_clis">
+Verifique quais CLIs de IA estão disponíveis no sistema:
+
+```bash
+# Verificar cada CLI
+command -v gemini >/dev/null 2>&1 && echo "gemini:available" || echo "gemini:missing"
+command -v claude >/dev/null 2>&1 && echo "claude:available" || echo "claude:missing"
+command -v codex >/dev/null 2>&1 && echo "codex:available" || echo "codex:missing"
+```
+
+Analise as flags de `$ARGUMENTS`:
+- `--gemini` → incluir Gemini
+- `--claude` → incluir Claude
+- `--codex` → incluir Codex
+- `--all` → incluir todos disponíveis
+- Sem flags → incluir todos disponíveis
+
+Se nenhuma CLI disponível:
+```
+Nenhuma CLI de IA externa encontrada. Instale pelo menos uma:
+- gemini: https://github.com/google-gemini/gemini-cli
+- codex: https://github.com/openai/codex
+- claude: https://github.com/anthropics/claude-code
+
+Depois execute /revisar novamente.
+```
+Encerre.
+
+Se apenas uma CLI é o runtime atual (ex.: executando dentro do Claude), pule-a para a revisão
+para garantir independência. Pelo menos uma CLI DIFERENTE deve estar disponível.
+</step>
+
+<step name="gather_context">
+Colete os artefatos da fase para o prompt de revisão:
+
+```bash
+INIT=$(node "./.claude/framework/bin/tools.cjs" init phase-op "${PHASE_ARG}")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Leia do init: `phase_dir`, `phase_number`, `padded_phase`.
+
+Depois leia:
+1. `.planning/PROJECT.md` (primeiras 80 linhas — contexto do projeto)
+2. Seção da fase em `.planning/ROADMAP.md`
+3. Todos os arquivos `*-PLAN.md` no diretório da fase
+4. `*-CONTEXT.md` se presente (decisões do usuário)
+5. `*-RESEARCH.md` se presente (pesquisa de domínio)
+6. `.planning/REQUIREMENTS.md` (requisitos que esta fase endereça)
+</step>
+
+<step name="build_prompt">
+Construa um prompt de revisão estruturado:
+
+```markdown
+# Cross-AI Plan Review Request
+
+You are reviewing implementation plans for a software project phase.
+Provide structured feedback on plan quality, completeness, and risks.
+
+## Project Context
+{first 80 lines of PROJECT.md}
+
+## Phase {N}: {phase name}
+### Roadmap Section
+{roadmap phase section}
+
+### Requirements Addressed
+{requirements for this phase}
+
+### User Decisions (CONTEXT.md)
+{context if present}
+
+### Research Findings
+{research if present}
+
+### Plans to Review
+{all PLAN.md contents}
+
+## Review Instructions
+
+Analyze each plan and provide:
+
+1. **Summary** — One-paragraph assessment
+2. **Strengths** — What's well-designed (bullet points)
+3. **Concerns** — Potential issues, gaps, risks (bullet points with severity: HIGH/MEDIUM/LOW)
+4. **Suggestions** — Specific improvements (bullet points)
+5. **Risk Assessment** — Overall risk level (LOW/MEDIUM/HIGH) with justification
+
+Focus on:
+- Missing edge cases or error handling
+- Dependency ordering issues
+- Scope creep or over-engineering
+- Security considerations
+- Performance implications
+- Whether the plans actually achieve the phase goals
+
+Output your review in markdown format.
+```
+
+Escreva em um arquivo temporário: `/tmp/review-prompt-{phase}.md`
+</step>
+
+<step name="invoke_reviewers">
+Para cada CLI selecionada, invoque em sequência (não em paralelo — evitar limites de taxa):
+
+**Gemini:**
+```bash
+gemini -p "$(cat /tmp/review-prompt-{phase}.md)" 2>/dev/null > /tmp/review-gemini-{phase}.md
+```
+
+**Claude (sessão separada):**
+```bash
+claude -p "$(cat /tmp/review-prompt-{phase}.md)" --no-input 2>/dev/null > /tmp/review-claude-{phase}.md
+```
+
+**Codex:**
+```bash
+codex exec --skip-git-repo-check "$(cat /tmp/review-prompt-{phase}.md)" 2>/dev/null > /tmp/review-codex-{phase}.md
+```
+
+Se uma CLI falhar, registre o erro e continue com as CLIs restantes.
+
+Exiba o progresso:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ framework ► REVISÃO CRUZADA ENTRE IAs — Fase {N}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+◆ Revisando com {CLI}... concluído ✓
+◆ Revisando com {CLI}... concluído ✓
+```
+</step>
+
+<step name="write_reviews">
+Combine todas as respostas de revisão em `{phase_dir}/{padded_phase}-REVIEWS.md`:
+
+```markdown
+---
+phase: {N}
+reviewers: [gemini, claude, codex]
+reviewed_at: {timestamp ISO}
+plans_reviewed: [{lista de arquivos PLAN.md}]
+---
+
+# Revisão Cruzada Entre IAs — Fase {N}
+
+## Revisão Gemini
+
+{conteúdo da revisão gemini}
+
+---
+
+## Revisão Claude
+
+{conteúdo da revisão claude}
+
+---
+
+## Revisão Codex
+
+{conteúdo da revisão codex}
+
+---
+
+## Resumo de Consenso
+
+{sintetize preocupações comuns entre todos os revisores}
+
+### Pontos Fortes Consensuais
+{pontos fortes mencionados por 2+ revisores}
+
+### Preocupações Consensuais
+{preocupações levantadas por 2+ revisores — prioridade mais alta}
+
+### Visões Divergentes
+{onde os revisores discordaram — vale investigar}
+```
+
+Commit:
+```bash
+node "./.claude/framework/bin/tools.cjs" commit "docs: revisão cruzada entre IAs para fase {N}" --files {phase_dir}/{padded_phase}-REVIEWS.md
+```
+</step>
+
+<step name="present_results">
+Exiba o resumo:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ framework ► REVISÃO CONCLUÍDA
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Fase {N} revisada por {contagem} sistemas de IA.
+
+Preocupações consensuais:
+{top 3 preocupações compartilhadas}
+
+Revisão completa: {padded_phase}-REVIEWS.md
+
+Para incorporar o feedback no planejamento:
+  /planejar-fase {N} --reviews
+```
+
+Limpe os arquivos temporários.
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Pelo menos uma CLI externa invocada com sucesso
+- [ ] REVIEWS.md escrito com feedback estruturado
+- [ ] Resumo de consenso sintetizado de múltiplos revisores
+- [ ] Arquivos temporários limpos
+- [ ] Usuário sabe como usar o feedback (/planejar-fase --reviews)
+</success_criteria>

package/kit/framework/workflows/session-report.md

@@ -0,0 +1,146 @@
+<purpose>
+Gerar um documento de resumo pós-sessão capturando o trabalho realizado, resultados alcançados e uso estimado de recursos. Escreve SESSION_REPORT.md em .planning/reports/ para revisão humana e compartilhamento com stakeholders.
+</purpose>
+
+<required_reading>
+Ler todos os arquivos referenciados pelo execution_context do prompt invocador antes de começar.
+</required_reading>
+
+<process>
+
+<step name="gather_session_data">
+Coletar dados da sessão das fontes disponíveis:
+
+1. **STATE.md** — fase atual, milestone, progresso, bloqueadores, decisões
+2. **Log do Git** — commits feitos durante esta sessão (últimas 24h ou desde o último relatório)
+3. **Arquivos de Plano/Summary** — planos executados, summaries escritos
+4. **ROADMAP.md** — contexto do milestone e objetivos de fase
+
+```bash
+# Obter commits recentes (últimas 24 horas)
+git log --oneline --since="24 hours ago" --no-merges 2>/dev/null || echo "Sem commits recentes"
+
+# Contar arquivos alterados
+git diff --stat HEAD~10 HEAD 2>/dev/null | tail -1 || echo "Nenhum diff disponível"
+```
+
+Ler `.planning/STATE.md` para obter:
+- Milestone e fase atuais
+- Percentual de progresso
+- Bloqueadores ativos
+- Decisões recentes
+
+Ler `.planning/ROADMAP.md` para obter nome e objetivos do milestone.
+
+Verificar relatórios existentes:
+```bash
+ls -la .planning/reports/SESSION_REPORT*.md 2>/dev/null || echo "Sem relatórios anteriores"
+```
+</step>
+
+<step name="estimate_usage">
+Estimar uso de tokens a partir de sinais observáveis:
+
+- A contagem de chamadas de ferramenta não está diretamente disponível, então estimar a partir de atividade do git e operações de arquivo
+- Nota: Esta é uma **estimativa** — contagens exatas de tokens requerem instrumentação em nível de API não disponível para hooks
+
+Heurísticas de estimativa:
+- Cada commit ≈ 1 ciclo de plano (pesquisa + plano + execução + verificação)
+- Cada arquivo de plano ≈ 2.000-5.000 tokens de contexto do agente
+- Cada arquivo de summary ≈ 1.000-2.000 tokens gerados
+- Criações de subagente multiplicam por ~1,5x por tipo de agente usado
+</step>
+
+<step name="generate_report">
+Criar o diretório e arquivo do relatório:
+
+```bash
+mkdir -p .planning/reports
+```
+
+Escrever `.planning/reports/SESSION_REPORT.md` (ou `.planning/reports/AAAAMMDD-session-report.md` se relatórios anteriores existirem):
+
+```markdown
+# Relatório de Sessão framework
+
+**Gerado:** [timestamp]
+**Projeto:** [do título do PROJECT.md ou nome do diretório]
+**Milestone:** [N] — [nome do milestone do ROADMAP.md]
+
+---
+
+## Resumo da Sessão
+
+**Duração:** [estimada do primeiro ao último timestamp de commit, ou "Sessão única"]
+**Progresso da Fase:** [do STATE.md]
+**Planos Executados:** [contagem de summaries escritos nesta sessão]
+**Commits Feitos:** [contagem do git log]
+
+## Trabalho Realizado
+
+### Fases Tocadas
+[Listar fases trabalhadas com breve descrição do que foi feito]
+
+### Resultados-Chave
+[Lista de entregáveis concretos: arquivos criados, funcionalidades implementadas, bugs corrigidos]
+
+### Decisões Tomadas
+[Da tabela de decisões do STATE.md, se alguma foi adicionada nesta sessão]
+
+## Arquivos Alterados
+
+[Resumo de arquivos modificados, criados, deletados — do git diff stat]
+
+## Bloqueadores e Itens em Aberto
+
+[Bloqueadores ativos do STATE.md]
+[Quaisquer itens TODO criados durante a sessão]
+
+## Uso Estimado de Recursos
+
+| Métrica | Estimativa |
+|---------|------------|
+| Commits | [N] |
+| Arquivos alterados | [N] |
+| Planos executados | [N] |
+| Subagentes criados | [estimado] |
+
+> **Nota:** Estimativas de tokens e custo requerem instrumentação em nível de API.
+> Essas métricas refletem apenas a atividade de sessão observável.
+
+---
+
+*Gerado por `/relatorio-sessao`*
+```
+</step>
+
+<step name="display_result">
+Mostrar ao usuário:
+
+```
+## Relatório de Sessão Gerado
+
+📄 `.planning/reports/[nome-do-arquivo].md`
+
+### Destaques
+- **Commits:** [N]
+- **Arquivos alterados:** [N]
+- **Progresso da fase:** [X]%
+- **Planos executados:** [N]
+```
+
+Se este for o primeiro relatório, mencionar:
+```
+💡 Execute `/relatorio-sessao` no final de cada sessão para construir um histórico de atividade do projeto.
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Dados da sessão coletados do STATE.md, git log e arquivos de plano
+- [ ] Relatório escrito em .planning/reports/
+- [ ] Relatório inclui resumo do trabalho, resultados e alterações de arquivos
+- [ ] Nome do arquivo inclui data para evitar sobrescritas
+- [ ] Resumo do resultado exibido ao usuário
+</success_criteria>

package/kit/framework/workflows/settings.md

@@ -0,0 +1,283 @@
+<purpose>
+Configuração interativa dos agentes de workflow framework (research, plan_check, verifier) e seleção de perfil de modelo via prompt de múltiplas perguntas. Atualiza .planning/config.json com as preferências do usuário. Opcionalmente salva as configurações como padrões globais (~/.framework/defaults.json) para projetos futuros.
+</purpose>
+
+<required_reading>
+Leia todos os arquivos referenciados pelo execution_context do prompt invocador antes de começar.
+</required_reading>
+
+<process>
+
+<step name="ensure_and_load_config">
+Garanta que o config existe e carregue o estado atual:
+
+```bash
+node "./.claude/framework/bin/tools.cjs" config-ensure-section
+INIT=$(node "./.claude/framework/bin/tools.cjs" state load)
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Cria `.planning/config.json` com valores padrão se ausente e carrega os valores de config atuais.
+</step>
+
+<step name="read_current">
+```bash
+cat .planning/config.json
+```
+
+Analise os valores atuais (padrão para `true` se não presente):
+- `workflow.research` — spawnar pesquisador durante plan-phase
+- `workflow.plan_check` — spawnar verificador de plano durante plan-phase
+- `workflow.verifier` — spawnar verificador durante execute-phase
+- `workflow.nyquist_validation` — pesquisa de arquitetura de validação durante plan-phase (padrão: true se ausente)
+- `workflow.ui_phase` — gerar contratos de design UI-SPEC.md para fases frontend (padrão: true se ausente)
+- `workflow.ui_safety_gate` — solicitar execução de /fase-ui antes de planejar fases frontend (padrão: true se ausente)
+- `model_profile` — qual modelo cada agente usa (padrão: `balanced`)
+- `git.branching_strategy` — abordagem de branching (padrão: `"none"`)
+</step>
+
+<step name="present_settings">
+Use AskUserQuestion com os valores atuais pré-selecionados:
+
+```
+AskUserQuestion([
+  {
+    question: "Qual perfil de modelo para os agentes?",
+    header: "Modelo",
+    multiSelect: false,
+    options: [
+      { label: "Qualidade", description: "Opus em todo lugar exceto verificação (maior custo)" },
+      { label: "Balanceado (Recomendado)", description: "Opus para planejamento, Sonnet para pesquisa/execução/verificação" },
+      { label: "Econômico", description: "Sonnet para escrita, Haiku para pesquisa/verificação (menor custo)" },
+      { label: "Herdar", description: "Usar o modelo da sessão atual para todos os agentes (melhor para OpenRouter, modelos locais, ou troca de modelo em runtime)" }
+    ]
+  },
+  {
+    question: "Spawnar Pesquisador de Plano? (pesquisa o domínio antes do planejamento)",
+    header: "Pesquisa",
+    multiSelect: false,
+    options: [
+      { label: "Sim", description: "Pesquisar objetivos da fase antes do planejamento" },
+      { label: "Não", description: "Pular pesquisa, planejar diretamente" }
+    ]
+  },
+  {
+    question: "Spawnar Verificador de Plano? (verifica os planos antes da execução)",
+    header: "Verificar Plano",
+    multiSelect: false,
+    options: [
+      { label: "Sim", description: "Verificar se os planos atendem os objetivos da fase" },
+      { label: "Não", description: "Pular verificação de plano" }
+    ]
+  },
+  {
+    question: "Spawnar Verificador de Execução? (verifica a conclusão da fase)",
+    header: "Verificador",
+    multiSelect: false,
+    options: [
+      { label: "Sim", description: "Verificar must-haves após a execução" },
+      { label: "Não", description: "Pular verificação pós-execução" }
+    ]
+  },
+  {
+    question: "Avanço automático do pipeline? (discutir → planejar → executar automaticamente)",
+    header: "Auto",
+    multiSelect: false,
+    options: [
+      { label: "Não (Recomendado)", description: "/clear manual + colar entre estágios" },
+      { label: "Sim", description: "Encadear estágios via subagentes Task() (mesma isolação)" }
+    ]
+  },
+  {
+    question: "Habilitar Validação Nyquist? (pesquisa cobertura de testes durante o planejamento)",
+    header: "Nyquist",
+    multiSelect: false,
+    options: [
+      { label: "Sim (Recomendado)", description: "Pesquisar cobertura de testes automatizados durante plan-phase. Adiciona requisitos de validação aos planos. Bloqueia aprovação se tarefas não tiverem verificação automatizada." },
+      { label: "Não", description: "Pular pesquisa de validação. Bom para prototipagem rápida ou fases sem testes." }
+    ]
+  },
+  // Nota: A validação Nyquist depende da saída da pesquisa. Se a pesquisa estiver desabilitada,
+  // o plan-phase pula automaticamente as etapas Nyquist (sem RESEARCH.md para extrair).
+  {
+    question: "Habilitar Fase UI? (gera contratos de design UI-SPEC.md para fases frontend)",
+    header: "Fase UI",
+    multiSelect: false,
+    options: [
+      { label: "Sim (Recomendado)", description: "Gerar contratos de design UI antes de planejar fases frontend. Bloqueia espaçamento, tipografia, cores e copywriting." },
+      { label: "Não", description: "Pular geração de UI-SPEC. Bom para projetos somente backend ou fases de API." }
+    ]
+  },
+  {
+    question: "Habilitar Gate de Segurança UI? (solicita executar /fase-ui antes de planejar fases frontend)",
+    header: "Gate UI",
+    multiSelect: false,
+    options: [
+      { label: "Sim (Recomendado)", description: "plan-phase pergunta para executar /fase-ui primeiro quando indicadores frontend detectados." },
+      { label: "Não", description: "Sem prompt — plan-phase prossegue sem verificação de UI-SPEC." }
+    ]
+  },
+  {
+    question: "Estratégia de branching no git?",
+    header: "Branching",
+    multiSelect: false,
+    options: [
+      { label: "Nenhuma (Recomendado)", description: "Commitar diretamente na branch atual" },
+      { label: "Por Fase", description: "Criar branch para cada fase (framework/phase-{N}-{name})" },
+      { label: "Por Marco", description: "Criar branch para o marco completo (framework/{versão}-{nome})" }
+    ]
+  },
+  {
+    question: "Habilitar avisos de janela de contexto? (injeta mensagens de aviso quando o contexto está ficando cheio)",
+    header: "Avisos de Ctx",
+    multiSelect: false,
+    options: [
+      { label: "Sim (Recomendado)", description: "Avisar quando o uso de contexto exceder 65%. Ajuda a evitar perda de trabalho." },
+      { label: "Não", description: "Desabilitar avisos. Permite que o Claude atinja o auto-compact naturalmente. Bom para execuções longas sem supervisão." }
+    ]
+  },
+  {
+    question: "Pesquisar melhores práticas antes de fazer perguntas? (busca na web durante new-project e discuss-phase)",
+    header: "Pesquisa Perguntas",
+    multiSelect: false,
+    options: [
+      { label: "Não (Recomendado)", description: "Fazer perguntas diretamente. Mais rápido, usa menos tokens." },
+      { label: "Sim", description: "Buscar melhores práticas na web antes de cada grupo de perguntas. Perguntas mais embasadas mas usa mais tokens." }
+    ]
+  },
+  {
+    question: "Pular discuss-phase no modo autônomo? (usar objetivos do ROADMAP como spec)",
+    header: "Pular Discuss",
+    multiSelect: false,
+    options: [
+      { label: "Não (Recomendado)", description: "Executar discuss inteligente antes de cada fase — apresenta áreas cinzentas e captura decisões." },
+      { label: "Sim", description: "Pular discuss no /autonomo — encadear diretamente para plan. Melhor para trabalho backend/pipeline onde as descrições de fase são a spec." }
+    ]
+  }
+])
+```
+</step>
+
+<step name="update_config">
+Mescle as novas configurações no config.json existente:
+
+```json
+{
+  ...existing_config,
+  "model_profile": "quality" | "balanced" | "budget" | "inherit",
+  "workflow": {
+    "research": true/false,
+    "plan_check": true/false,
+    "verifier": true/false,
+    "auto_advance": true/false,
+    "nyquist_validation": true/false,
+    "ui_phase": true/false,
+    "ui_safety_gate": true/false,
+    "text_mode": true/false,
+    "research_before_questions": true/false,
+    "discuss_mode": "discuss" | "assumptions",
+    "skip_discuss": true/false
+  },
+  "git": {
+    "branching_strategy": "none" | "phase" | "milestone",
+    "quick_branch_template": <string|null>
+  },
+  "hooks": {
+    "context_warnings": true/false,
+    "workflow_guard": true/false
+  }
+}
+```
+
+Escreva o config atualizado em `.planning/config.json`.
+</step>
+
+<step name="save_as_defaults">
+Pergunte se deseja salvar estas configurações como padrões globais para projetos futuros:
+
+```
+AskUserQuestion([
+  {
+    question: "Salvar como configurações padrão para todos os novos projetos?",
+    header: "Padrões",
+    multiSelect: false,
+    options: [
+      { label: "Sim", description: "Novos projetos começam com estas configurações (salvo em ~/.framework/defaults.json)" },
+      { label: "Não", description: "Aplicar apenas a este projeto" }
+    ]
+  }
+])
+```
+
+Se "Sim": escreva o mesmo objeto de config (menos campos específicos do projeto como `brave_search`) em `~/.framework/defaults.json`:
+
+```bash
+mkdir -p ~/.framework
+```
+
+Escreva `~/.framework/defaults.json` com:
+```json
+{
+  "mode": <atual>,
+  "granularity": <atual>,
+  "model_profile": <atual>,
+  "commit_docs": <atual>,
+  "parallelization": <atual>,
+  "branching_strategy": <atual>,
+  "quick_branch_template": <atual>,
+  "workflow": {
+    "research": <atual>,
+    "plan_check": <atual>,
+    "verifier": <atual>,
+    "auto_advance": <atual>,
+    "nyquist_validation": <atual>,
+    "ui_phase": <atual>,
+    "ui_safety_gate": <atual>,
+    "skip_discuss": <atual>
+  }
+}
+```
+</step>
+
+<step name="confirm">
+Exiba:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ framework ► CONFIGURAÇÕES ATUALIZADAS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+| Configuração              | Valor |
+|---------------------------|-------|
+| Perfil de Modelo          | {quality/balanced/budget/inherit} |
+| Pesquisador de Plano      | {Ativo/Inativo} |
+| Verificador de Plano      | {Ativo/Inativo} |
+| Verificador de Execução   | {Ativo/Inativo} |
+| Avanço Automático         | {Ativo/Inativo} |
+| Validação Nyquist         | {Ativo/Inativo} |
+| Fase UI                   | {Ativo/Inativo} |
+| Gate UI                   | {Ativo/Inativo} |
+| Branching Git             | {Nenhuma/Por Fase/Por Marco} |
+| Pular Discuss             | {Ativo/Inativo} |
+| Avisos de Contexto        | {Ativo/Inativo} |
+| Salvo como Padrões        | {Sim/Não} |
+
+Estas configurações se aplicam às futuras execuções de /planejar-fase e /executar-fase.
+
+Comandos rápidos:
+- /definir-perfil <perfil> — trocar perfil de modelo
+- /planejar-fase --research — forçar pesquisa
+- /planejar-fase --skip-research — pular pesquisa
+- /planejar-fase --skip-verify — pular verificação de plano
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Config atual lido
+- [ ] Usuário apresentado com 10 configurações (perfil + 8 toggles de workflow + branching git)
+- [ ] Config atualizado com seções model_profile, workflow e git
+- [ ] Usuário ofereceu salvar como padrões globais (~/.framework/defaults.json)
+- [ ] Mudanças confirmadas ao usuário
+</success_criteria>