@onion-ai/cli 1.0.0-beta.1

package/framework/commands/engineer/hotfix.md

@@ -0,0 +1,183 @@
+---
+name: hotfix
+description: |
+  Emergency workflow completo: task ClickUp + branch hotfix + desenvolvimento.
+  Use para correções urgentes em produção.
+model: sonnet
+parameters:
+  - name: description
+    description: Descrição do hotfix
+    required: true
+  - name: related_tasks
+    description: IDs de tasks relacionadas (comma-separated)
+    required: false
+  - name: tags
+    description: Tags adicionais (comma-separated)
+    required: false
+
+category: engineer
+tags:
+  - hotfix
+  - emergency
+  - gitflow
+
+version: '3.0.0'
+updated: '2025-11-24'
+
+related_commands:
+  - /git/hotfix/start
+  - /git/hotfix/finish
+  - /product/task
+
+related_agents:
+  - gitflow-specialist
+  - clickup-specialist
+---
+
+# 🔥 Engineer Hotfix
+
+Emergency workflow completo: Task + Branch + Desenvolvimento.
+
+## 🎯 Objetivo
+
+Executar workflow de hotfix end-to-end em um único comando.
+
+## ⚡ Fluxo de Execução
+
+### Passo 1: Validar Input
+
+```bash
+# Verificar descrição
+if [ -z "{{description}}" ]; then
+  echo "❌ Descrição obrigatória"
+  exit 1
+fi
+
+# Verificar branch atual
+CURRENT=$(git branch --show-current)
+if [[ ! "$CURRENT" =~ ^(main|master|develop)$ ]]; then
+  echo "⚠️ Recomendado: iniciar de main/master"
+fi
+```
+
+### Passo 2: Criar Task Emergencial
+
+Via ClickUp MCP:
+
+```yaml
+name: '🔥 HOTFIX: {{description}}'
+list_id: [lista de hotfixes]
+priority: urgent
+tags:
+  - hotfix
+  - urgent
+  - { { tags } }
+status: 'In Progress'
+markdown_description: |
+  ## 🚨 Emergency Hotfix
+
+  **Descrição**: {{description}}
+
+  ## 📋 Checklist
+  - [ ] Diagnóstico
+  - [ ] Implementação
+  - [ ] Testes
+  - [ ] Deploy
+```
+
+### Passo 3: Criar Branch Hotfix
+
+```bash
+# Garantir main atualizada
+git checkout main
+git pull origin main
+
+# Criar hotfix branch
+VERSION=$(cat package.json | grep version | head -1 | awk -F'"' '{print $4}')
+PATCH=$(echo $VERSION | awk -F. '{print $1"."$2"."$3+1}')
+BRANCH="hotfix/$PATCH-$(echo '{{description}}' | tr ' ' '-' | tr '[:upper:]' '[:lower:]' | head -c 30)"
+
+git checkout -b $BRANCH
+```
+
+### Passo 4: Setup Session
+
+```bash
+# Criar sessão de desenvolvimento
+mkdir -p .claude/sessions/hotfix-$(date +%Y%m%d)/
+
+# Criar context.md
+cat > .claude/sessions/hotfix-$(date +%Y%m%d)/context.md << EOF
+# Hotfix Context
+
+## Task
+- ID: [task_id criado]
+- URL: [url do clickup]
+
+## Branch
+- Nome: $BRANCH
+- Base: main
+
+## Descrição
+{{description}}
+EOF
+```
+
+### Passo 5: Iniciar Desenvolvimento
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔥 HOTFIX INICIADO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📋 Task: [URL do ClickUp]
+🌿 Branch: hotfix/X.X.X-description
+
+⚡ Próximos Passos:
+1. Implementar correção
+2. Testar localmente
+3. /engineer/pre-pr
+4. /git/hotfix/finish
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## 📤 Output Esperado
+
+### Sucesso
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ HOTFIX SETUP COMPLETO
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📋 ClickUp:
+∟ Task: 🔥 HOTFIX: {{description}}
+∟ ID: 86adfxxxx
+∟ Status: In Progress
+∟ Priority: Urgent
+
+🌿 Git:
+∟ Branch: hotfix/1.2.3-fix-description
+∟ Base: main
+∟ Remote: origin
+
+📁 Session:
+∟ Path: .claude/sessions/hotfix-20251124/
+
+🚀 Comandos:
+∟ Desenvolver: /engineer/work
+∟ Pre-PR: /engineer/pre-pr
+∟ Finalizar: /git/hotfix/finish
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## 🔗 Referências
+
+- Padrões: `common/prompts/git-workflow-patterns.md`
+- Agente: @gitflow-specialist
+
+## ⚠️ Notas
+
+- Sempre parte de `main` ou `master`
+- Task criada com prioridade máxima
+- Merge automático para main E develop no finish

package/framework/commands/engineer/plan.md

@@ -0,0 +1,85 @@
+---
+name: plan
+description: Planejamento de feature. Analisa e cria plano estruturado.
+model: sonnet
+category: engineer
+tags: [planning, architecture, design]
+version: '3.0.0'
+updated: '2025-11-24'
+---
+
+# Engineer Reason
+
+Este é o comando para iniciar o planejamento de uma funcionalidade.
+
+<arguments>
+#$ARGUMENTS
+</arguments>
+
+## Análise
+
+Leia os arquivos context.md e architecture.md na pasta .claude/sessions/<feature-slug> se ainda não tiver feito.
+
+Sua tarefa agora é criar um plano de implementação detalhado (plan.md) para esta funcionalidade. O objetivo desta documentação é criar uma abordagem de implementação faseada que nos permita construir a funcionalidade incrementalmente, testando cada fase conforme avançamos. E também deve tornar possível retomar o trabalho caso nossa sessão seja interrompida.
+
+O plan.md deve dividir a implementação em fases, cada fase com um pedaço do trabalho que pode ser realizado por um humano em 2 horas.
+
+O template para o plan.md é:
+
+<plan>
+# [NOME DA FUNCIONALIDADE]
+
+Se você está trabalhando nesta funcionalidade, certifique-se de atualizar este arquivo plan.md conforme progride.
+
+## FASE 1 [Completada ✅]
+
+Detalhes desta parte da funcionalidade
+
+### Uma tarefa que foi feita [Completada ✅]
+
+Detalhes sobre a tarefa
+
+### Uma tarefa que foi feita [Completada ✅]
+
+Detalhes sobre a tarefa
+
+### Comentários:
+
+- Algo que aconteceu e nos forçou a mudar de direção
+- Algo que aprendemos durante o desenvolvimento
+- Algo que discutimos e concordamos
+
+## FASE 2 [Em Progresso ⏰]
+
+### Uma tarefa que precisa ser feita [Em Progresso ⏰]
+
+Detalhes sobre a tarefa
+
+### Uma tarefa que precisa ser feita [Não Iniciada ⏳]
+
+Detalhes sobre a tarefa
+
+## FASE 3 [Não Iniciada ⏳]
+
+### Uma tarefa que precisa ser feita [Não Iniciada ⏳]
+
+Detalhes sobre a tarefa
+
+### Uma tarefa que precisa ser feita [Não Iniciada ⏳]
+
+Detalhes sobre a tarefa
+
+</plan>
+
+Dicas:
+
+- Use repoprompt:search (se disponível) para encontrar arquivos específicos baseados nas respostas de descoberta
+- Use repoprompt:set_selection e repoprompt:read_selected_files (se disponível) para ler código relevante em batch
+- Analise detalhes específicos de implementação
+- Use WebSearch e ou context7 para melhores práticas ou documentação de bibliotecas (se necessário)
+
+No caso desta pesquisa levantar uma nova decisão arquitetural ou contradição com as decisões anteriores, você iniciará uma discussão sobre isso com o humano, concordará com as mudanças e atualizará o documento architecture.md para aquela funcionalidade se necessário.
+
+Este documento também deve anotar quais tarefas precisam ser feitas sequencialmente ou em paralelo.
+
+Uma vez que o plan.md esteja finalizado, informe ao humano que você está pronto para prosseguir para o próximo passo.

package/framework/commands/engineer/pr-update.md

@@ -0,0 +1,219 @@
+---
+name: pr-update
+description: Atualizar PR existente com mudanças adicionais.
+model: sonnet
+category: engineer
+tags: [pr, update, git]
+version: '3.0.0'
+updated: '2025-11-24'
+---
+
+# 🔄 Engineer PR Update
+
+Atualizar um Pull Request existente com mudanças adicionais. Este comando automatiza o processo completo de commit, push e documentação quando você já executou `/engineer/pr` mas fez mudanças subsequentes.
+
+## 🎯 Funcionalidades
+
+### Detecção Automática de Contexto
+
+- Identifica automaticamente a branch de feature ativa
+- Detecta mudanças pendentes (staged/unstaged/untracked)
+- Valida se existe PR aberto para a branch atual
+- Verifica se está na sessão de desenvolvimento correta
+
+### Commit Inteligente e Descritivo
+
+- Analisa arquivos modificados para categorizar mudanças
+- Gera mensagem de commit contextual e descritiva
+- Suporta diferentes tipos de mudanças (fix, feat, docs, refactor)
+- Mantém histórico limpo com commits atômicos
+
+### Sincronização Automática
+
+- Push automático para branch do PR existente
+- Atualização do ClickUp com comentário detalhado
+- Validação de que PR foi atualizado com sucesso
+- Timestamp e métricas das mudanças aplicadas
+
+## 🚀 Como Usar
+
+```bash
+/engineer/pr-update
+```
+
+### Exemplos com Parâmetros Opcionais
+
+```bash
+/engineer/pr-update                           # Análise automática + commit inteligente
+/engineer/pr-update --type fix               # Força tipo de commit específico
+/engineer/pr-update --message "Custom msg"   # Mensagem personalizada
+/engineer/pr-update --dry-run               # Preview sem executar
+```
+
+## 🤝 Integração ClickUp MCP
+
+### Detecção de Task Ativa
+
+- Lê task ID do arquivo `.claude/sessions/[slug]/context.md`
+- Identifica PR existente através da task ou branch
+- Valida se task está em status "in progress" com tag "under-review"
+
+### Comentário Automático Padronizado
+
+**Chamar abstração MCP para documentação de atualização:**
+
+```typescript
+// Ao atualizar PR com novos commits, chamar:
+await commentPRUpdated(taskId, {
+  commitType: 'fix|feat|refactor|docs|chore',
+  commitHash: '[hash do commit]',
+  filesModified: N,
+  linesAdded: N,
+  linesRemoved: N,
+  description: '[descrição das mudanças]',
+});
+```
+
+**Referências:**
+
+- **Padrão 4 (PR Atualizada)**: `.claude/docs/strategies/clickup-comment-patterns.md`
+- **Abstração MCP**: `commentPRUpdated()` em `.claude/utils/clickup-mcp-wrappers.md` (linhas 632-661)
+
+## ⚙️ Processo Automático
+
+1. **Validação de Contexto**: Confirma branch de feature + sessão ativa
+2. **Análise de Mudanças**: Categoriza arquivos modificados por tipo
+3. **Geração de Commit**: Cria mensagem contextual e descritiva
+4. **Staging Inteligente**: Adiciona apenas arquivos relevantes
+5. **Commit & Push**: Executa commit + push para branch do PR
+6. **Atualização ClickUp**: Documenta mudanças com comentário formatado
+7. **Validação Final**: Confirma que PR foi atualizado com sucesso
+
+## 🧠 Detecção Inteligente de Tipos
+
+### Tipos de Commit Auto-Detectados
+
+- **fix**: Correções de bugs, patches, hotfixes
+- **feat**: Novas funcionalidades, enhancements
+- **docs**: Mudanças apenas em documentação
+- **refactor**: Refatoração sem mudança de funcionalidade
+- **style**: Formatação, linting, style fixes
+- **test**: Adição ou correção de testes
+- **chore**: Tarefas de manutenção, configuração
+
+### Análise de Arquivos Modificados
+
+```markdown
+## Categorização Automática:
+
+- `.claude/commands/` → "feat/fix: Comando updates"
+- `docs/` → "docs: Documentation updates"
+- `tests/` → "test: Test updates"
+- `*.md` (session files) → "chore: Session documentation"
+- Múltiplos tipos → "chore: Multiple updates"
+```
+
+## ⚠️ Resolução de Problemas
+
+### Problema: "Não há PR ativo para esta branch"
+
+**Solução**: Executar `/engineer/pr` primeiro para criar o PR inicial
+
+```bash
+# Se necessário, criar PR primeiro:
+/engineer/pr
+```
+
+### Problema: "Nenhuma mudança detectada"
+
+**Solução**: Verificar se há arquivos modificados
+
+```bash
+git status  # Confirmar mudanças pendentes
+```
+
+### Problema: "Branch não está sincronizada"
+
+**Solução**: Sincronizar branch antes de atualizar
+
+```bash
+git pull origin [branch-name]  # Sincronizar primeiro
+/engineer/pr-update           # Depois atualizar
+```
+
+### Problema: "Task ClickUp não encontrada"
+
+**Solução**: Verificar context.md da sessão ativa
+
+- Confirmar task ID no arquivo `.claude/sessions/[slug]/context.md`
+- Validar se task existe e está acessível
+
+## 💡 Casos de Uso Comuns
+
+### 1. Correções Pós-Review
+
+```bash
+# Após feedback do code review:
+# 1. Fazer correções solicitadas
+# 2. Executar:
+/engineer/pr-update --type fix
+```
+
+### 2. Melhorias Adicionais
+
+```bash
+# Após pensar em melhorias:
+# 1. Implementar enhancements
+# 2. Executar:
+/engineer/pr-update --type feat
+```
+
+### 3. Documentação Esquecida
+
+```bash
+# Após lembrar de documentar:
+# 1. Atualizar docs
+# 2. Executar:
+/engineer/pr-update --type docs
+```
+
+### 4. Correções Arquiteturais
+
+```bash
+# Como no exemplo atual:
+# 1. Implementar correções arquiteturais
+# 2. Executar:
+/engineer/pr-update --type fix --message "Correção arquitetural - Phase→Subtask sync"
+```
+
+## 🔗 Integração com Workflow
+
+### Fluxo Padrão Completo
+
+1. `/product/task` - Criar task ClickUp
+2. `/engineer/start` - Iniciar desenvolvimento
+3. `/engineer/work` - Desenvolver features
+4. `/engineer/pre-pr` - Validações finais
+5. `/engineer/pr` - Criar Pull Request
+6. **`/engineer/pr-update`** - Atualizar PR com mudanças adicionais (quantas vezes necessário)
+7. Merge do PR → Auto-sync `/git/sync`
+
+### Compatibilidade com Comandos Existentes
+
+- ✅ Funciona após `/engineer/pr`
+- ✅ Integra com `/engineer/work` progress tracking
+- ✅ Compatível com `/git/sync` automático pós-merge
+- ✅ Respeita mapeamento Phase→Subtask do context.md
+
+---
+
+**🎯 VALOR AGREGADO: Este comando elimina o processo manual de atualização de PRs, automatizando commit inteligente, push, e documentação ClickUp em uma única operação otimizada.**
+
+## 📈 Benefícios
+
+- ⚡ **Automação completa** do processo de update
+- 🧠 **Commits inteligentes** com mensagens contextuais
+- 📝 **Documentação automática** no ClickUp
+- 🔄 **Consistência** no workflow de PRs
+- ⏰ **Economia de tempo** significativa
+- 🎯 **Redução de erros** manuais

package/framework/commands/engineer/pr.md

@@ -0,0 +1,117 @@
+---
+name: pr
+description: Criar Pull Request com integração GitFlow e sync automático.
+model: sonnet
+category: engineer
+tags: [pr, gitflow, workflow]
+version: '3.0.0'
+updated: '2025-11-24'
+---
+
+# 🚀 Engineer PR - GitFlow Integrated
+
+Você é um assistente especializado em **criação de Pull Requests** com integração automática ao novo sistema `/git/sync` otimizado do Sistema Onion.
+
+## 🤖 **Nova Integração GitFlow**
+
+Este comando agora inclui **sync automático pós-merge** usando:
+
+- **GitFlow Analysis** via @gitflow-specialist
+- **Performance otimizada** (cache + operações paralelas)
+- **Cleanup inteligente** baseado na estratégia de branch
+- **Session archiving** automático
+- **ClickUp auto-update** para status "Done"
+
+---
+
+Agora é solicitado que você faça um PR. Siga estes passos cuidadosamente para completar a tarefa:
+
+1. Primeiro, garanta que todos os testes estão funcionando para a branch atual. Execute a suíte de testes apropriada para seu projeto e confirme que todos os testes passam. Se algum teste falhar, corrija os problemas antes de prosseguir.
+
+2. **CRÍTICO - Criar Feature Branch PRIMEIRO:**
+   a. Crie uma feature branch a partir da branch base (develop/main):
+
+   ```bash
+   git checkout -b feature/[descricao-sucinta]
+   git push -u origin feature/[descricao-sucinta]
+   ```
+
+   b. Faça commit das mudanças que você fez. Use uma mensagem de commit clara e concisa que resuma as alterações.
+   c. Push dos commits para a feature branch.
+
+3. Mova a task do ClickUp associada com esta tarefa para o status "in progress" e adicione a tag "under-review".
+
+4. Adicione um comentário na task do ClickUp documentando o PR:
+
+**Chamar abstração MCP para comentário automatizado:**
+
+```typescript
+// Ao criar PR, chamar:
+await commentPRCreated(taskId, {
+  prUrl: '[PR_URL]',
+  branch: '[branch-name]',
+  changesDescription: '[descrição das mudanças]',
+  testsStatus: 'passing|review|pending',
+});
+```
+
+**Referências:**
+
+- **Padrão 3 (PR Criada)**: `.claude/docs/strategies/clickup-comment-patterns.md`
+- **Abstração MCP**: `commentPRCreated()` em `.claude/utils/clickup-mcp-wrappers.md` (linhas 632-661)
+
+5. Abra um Pull Request (PR) com os detalhes da implementação:
+
+   Importante: Não mencione nenhum código relacionado a AI ou assistentes de IA no PR.
+
+6. Após abrir o PR, aguarde 3 minutos e então verifique comentários da ferramenta automatizada de code review. Se nenhum comentário aparecer, aguarde mais 3 minutos e verifique novamente.
+
+7. Uma vez que você receba comentários da ferramenta automatizada de code review, analise cada comentário cuidadosamente. Determine quais comentários requerem correções e quais podem ser ignorados com segurança ou explicados. Apresente suas sugestões ao usuário e peça permissão para fazer as mudanças.
+
+8. Para os comentários que requerem correções:
+   a. Faça as mudanças necessárias no código
+   b. Faça commit dessas mudanças com uma mensagem de commit clara
+   c. Faça push do(s) novo(s) commit(s) para a mesma branch
+
+9. Após abordar os comentários e fazer push das atualizações, aguarde a confirmação de merge do PR.
+
+10. **NOVO - Sync Automático Pós-Merge**: Uma vez que o PR for merged, execute automaticamente:
+
+    ```bash
+    /git/sync
+    ```
+
+    Este comando agora inclui:
+    - 🤖 **GitFlow Analysis** com @gitflow-specialist
+    - ⚡ **Performance otimizada** (cache + operações paralelas)
+    - 🧹 **Cleanup inteligente** baseado na estratégia GitFlow
+    - 📁 **Session management** automático com archiving
+    - 🔗 **ClickUp auto-update** para status "Done"
+
+    O sync será executado automaticamente com a estratégia otimizada baseada no tipo de branch e workflow detectado.
+
+REGRA DE OURO: Sempre faça commit APENAS dos arquivos que você alterou. SE houver mais arquivos, pergunte ao usuário se eels devem ser incluidos. Não use `git add .` para prevenir commits de arquivos que não deveriam ser commitados, a não ser que o usuario confirme.
+
+Seu output final deve ser uma mensagem para o usuário, formatada da seguinte forma:
+
+<task_completion_message>
+Tarefa completada:
+
+- Testes estão passando
+- Mudanças commitadas
+- Task do ClickUp [INSERT TASK ID] movida para "in progress" com tag "under-review"
+- PR aberto: [INSERT PR TITLE]
+- Comentários do code review automatizado abordados e correções pushed
+- 🤖 GitFlow integration: Auto-sync configurado para pós-merge
+
+O PR está agora pronto para sua revisão final e merge manual.
+
+🚀 APÓS O MERGE: O comando `/git/sync` será executado automaticamente com:
+∟ GitFlow analysis via @gitflow-specialist
+∟ Performance otimizada (cache + operações paralelas)
+∟ Cleanup inteligente baseado na estratégia GitFlow
+∟ Session archiving automático
+∟ ClickUp auto-update para status "Done"
+
+[INSERT PR LINK]
+</task_completion_message>

package/framework/commands/engineer/pre-pr.md

@@ -0,0 +1,81 @@
+---
+name: pre-pr
+description: Validação completa antes do PR. Verifica padrões e qualidade.
+model: sonnet
+category: engineer
+tags: [validation, pr, quality]
+version: '3.0.0'
+updated: '2025-11-24'
+---
+
+# Pre-PR - Validação Completa Antes do Pull Request
+
+Estamos nos aproximando de finalizar o trabalho nesta branch e nos preparar para um pull request. Agora, é hora de fazer verificações finais e limpezas para garantir que estamos alinhados com nossos padrões e objetivos.
+
+## 🔄 **Auto-Update ClickUp**
+
+Este comando **automaticamente atualiza** a task ClickUp durante preparação para PR:
+
+### **✅ Updates Automáticos SEMPRE:**
+
+- **Validação de critérios de aceitação** - Verifica todos os checkboxes
+- **Comentário de preparação** com checklist completo
+- **Tag 'ready-for-pr'** quando todas verificações passam
+- **Tag 'needs-fixes'** se verificações falham
+- **Progresso estimado** para 90% (quase pronto)
+
+### **💬 Formato do Comentário de Pre-PR:**
+
+**Chamar abstrações MCP para validação automatizada:**
+
+```typescript
+// 1. Validar Critérios de Aceitação
+const validation = await validateAcceptanceCriteria(taskId);
+// Retorna: { isComplete, coverage, criteria[], pendingCriteria[] }
+
+// 2. Criar comentário de validação com resultado
+await commentPrePRValidation(taskId, {
+  validationResult: validation,
+  technicalChecks: { metaSpecs: true, codeReview: true, tests: true },
+  readyForPR: validation.isComplete,
+});
+```
+
+**Referências:**
+
+- **Padrão 5 (Validação Pre-PR)**: `.claude/docs/strategies/clickup-comment-patterns.md`
+- **Abstrações MCP**:
+  - `validateAcceptanceCriteria()` em `.claude/utils/clickup-mcp-wrappers.md` (linhas 534-600)
+  - `commentPrePRValidation()` em `.claude/utils/clickup-mcp-wrappers.md` (linhas 603-629)
+
+### **📋 Identificação da Task:**
+
+1. **Context.md**: Lê task-id da sessão ativa
+2. **Branch atual**: Detecta automaticamente pela branch git
+
+## Checklist de Preparação:
+
+### ✅ Validação de Critérios de Aceitação:
+
+1. **Extrair critérios** - Ler checkboxes da description da task/subtask
+2. **Validar cobertura** - Confirmar que TODOS os checkboxes estão marcados `[x]`
+3. **Gerar relatório** - Criar lista de critérios validados
+4. **Bloquear se incompleto** - Se algum critério não estiver marcado, indicar no comentário
+
+### 🔧 Validações Técnicas:
+
+1. Invoque o agente `branch-metaspec-checker` para verificar se a branch está alinhada com as meta specs do projeto.
+2. Invoque o agente `branch-code-reviewer` para revisar o código e garantir que está bom para lançar.
+3. Invoque o agente `branch-documentation-writer` para atualizar a documentação do projeto.
+4. Invoque o agente `branch-test-planner` para finalizar a escrita de testes para a branch.
+
+### 📋 AUTO-UPDATE:
+
+5. **Validar critérios de aceitação** - Verificar todos os checkboxes
+6. **Adicionar comentário de preparação** no ClickUp automaticamente
+7. **Aplicar tags** (ready-for-pr ou needs-fixes)
+8. **Atualizar progresso** para 90%
+
+Você também precisará lidar com todo o feedback que esses agentes fornecerem e fazer mudanças e correções conforme necessário.
+
+Uma vez terminado E todos os critérios de aceitação validados, me avise e peça minha permissão para abrir o Pull Request.