@thiagodiogo/pscode 1.0.0 → 2.0.0

package/pscode/content/dixi/context/java/naming.md

@@ -0,0 +1,62 @@
+# Convenções de Nomenclatura — Java/Spring
+
+## Regra geral
+
+O nome deve revelar o papel da classe na arquitetura hexagonal. Evite sufixos técnicos no domínio; use sufixos técnicos apenas na infraestrutura.
+
+## Domain
+
+Substantivos sem sufixo técnico. Nomes de negócio, não de tecnologia.
+
+| Tipo             | Padrão               | Exemplos válidos                       | Inválidos                          |
+|------------------|----------------------|----------------------------------------|------------------------------------|
+| Entidade         | `NomeDominio`        | `Pedido`, `Usuario`, `Produto`         | `PedidoEntity`, `UsuarioModel`     |
+| Value Object     | `NomeDominio`        | `Email`, `CPF`, `PedidoId`             | `EmailVO`, `CPFValue`              |
+| Exceção domínio  | `Motivo + Exception` | `PedidoVazioException`, `SaldoInsuficienteException` | `PedidoError`, `InvalidPedido` |
+| Porta de entrada | `Verbo + UseCase`    | `ConfirmarPedidoUseCase`, `BuscarUsuarioUseCase` | `PedidoService`, `PedidoPort` |
+| Porta de saída   | `NomeDominio + Repository/Gateway` | `PedidoRepository`, `NotificacaoGateway` | `IPedidoRepo`, `PedidoDAO` |
+
+## Application
+
+Implementações dos use cases. Verbo + sufixo `Service`.
+
+| Tipo        | Padrão              | Exemplos válidos                          | Inválidos                        |
+|-------------|---------------------|-------------------------------------------|----------------------------------|
+| Use Case impl | `Verbo + Service` | `ConfirmarPedidoService`, `CadastrarUsuarioService` | `PedidoServiceImpl`, `OrderManager` |
+
+## Infrastructure
+
+Sufixos técnicos que revelam o mecanismo de implementação.
+
+| Tipo                   | Padrão                    | Exemplos válidos                              |
+|------------------------|---------------------------|-----------------------------------------------|
+| Controller REST        | `Dominio + Controller`    | `PedidoController`, `UsuarioController`       |
+| JPA Entity             | `Dominio + JpaEntity`     | `PedidoJpaEntity`, `UsuarioJpaEntity`         |
+| JPA Repository impl    | `Dominio + JpaRepository` | `PedidoJpaRepository`                         |
+| Spring Data interface  | `Dominio + JpaEntityRepository` | `PedidoJpaEntityRepository`             |
+| HTTP Client            | `Servico + Client`        | `PagamentoClient`, `NotificacaoClient`        |
+| Message Consumer       | `Evento + Consumer`       | `PedidoCriadoConsumer`                        |
+| Message Producer       | `Evento + Producer`       | `PedidoConfirmadoProducer`                    |
+| Mapper                 | `Dominio + Mapper`        | `PedidoMapper`, `UsuarioMapper`               |
+| DTO de entrada         | `Acao + Request`          | `ConfirmarPedidoRequest`, `CadastrarUsuarioRequest` |
+| DTO de saída           | `Dominio + Response`      | `PedidoResponse`, `UsuarioResponse`           |
+
+## Packages
+
+Siga a estrutura hexagonal. Use nomes de domínio em lowercase, sem underscores.
+
+```
+com.empresa.produto.pedido.domain.model
+com.empresa.produto.pedido.domain.port.in
+com.empresa.produto.pedido.application.usecase
+com.empresa.produto.pedido.infrastructure.adapter.in
+```
+
+## Métodos
+
+| Tipo                   | Padrão                | Exemplos                                         |
+|------------------------|-----------------------|--------------------------------------------------|
+| Use case (comando)     | verbo no infinitivo   | `confirmar()`, `cancelar()`, `processar()`       |
+| Use case (query)       | `buscar/listar/obter` | `buscarPorId()`, `listarAtivos()`, `obterSaldo()`|
+| Domain action          | verbo de negócio      | `ativar()`, `debitar()`, `aplicarDesconto()`     |
+| Factory method         | `criar/novo`          | `criar()`, `criarVazio()`, `novaInstancia()`     |

package/pscode/content/dixi/context/java/testing.md

@@ -0,0 +1,162 @@
+# Testes — Java/Spring
+
+## Pirâmide de testes
+
+```
+        [E2E — RestAssured]          ← poucos, fluxos críticos
+      [Integração — Testcontainers]  ← adapters de saída, APIs
+    [Unitários — JUnit 5 + Mockito]  ← domain e application (maioria)
+```
+
+## Nível 1 — Testes unitários (domain e application)
+
+Testam lógica pura sem Spring, sem banco, sem rede.
+
+**Ferramentas:** JUnit 5, Mockito
+
+**Onde ficam:** `test/java/.../domain/` e `test/java/.../application/`
+
+```java
+// Teste de domain
+class PedidoTest {
+    @Test
+    void dado_pedido_com_itens_quando_confirmar_entao_status_confirmado() {
+        // Given
+        Pedido pedido = PedidoTestFactory.comUmItem();
+
+        // When
+        pedido.confirmar();
+
+        // Then
+        assertThat(pedido.getStatus()).isEqualTo(StatusPedido.CONFIRMADO);
+    }
+
+    @Test
+    void dado_pedido_vazio_quando_confirmar_entao_lanca_excecao() {
+        Pedido pedido = PedidoTestFactory.vazio();
+        assertThatThrownBy(pedido::confirmar)
+            .isInstanceOf(PedidoVazioException.class);
+    }
+}
+```
+
+```java
+// Teste de application (use case)
+class ConfirmarPedidoServiceTest {
+    @Mock PedidoRepository repository;
+    @InjectMocks ConfirmarPedidoService service;
+
+    @Test
+    void dado_pedido_existente_quando_confirmar_entao_salva_e_retorna() {
+        // Given
+        Pedido pedido = PedidoTestFactory.comUmItem();
+        when(repository.findById(pedido.getId())).thenReturn(Optional.of(pedido));
+        when(repository.save(any())).thenAnswer(inv -> inv.getArgument(0));
+
+        // When
+        Pedido resultado = service.confirmar(pedido.getId());
+
+        // Then
+        assertThat(resultado.getStatus()).isEqualTo(StatusPedido.CONFIRMADO);
+        verify(repository).save(pedido);
+    }
+}
+```
+
+## Nível 2 — Testes de integração (infrastructure)
+
+Testam adapters com dependências reais (banco, mensageria, APIs externas).
+
+**Ferramentas:** Testcontainers, `@SpringBootTest` com perfil de teste
+
+**Onde ficam:** `test/java/.../infrastructure/`
+
+```java
+@SpringBootTest
+@Testcontainers
+class PedidoJpaRepositoryIT {
+    @Container
+    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16");
+
+    @DynamicPropertySource
+    static void props(DynamicPropertyRegistry r) {
+        r.add("spring.datasource.url", postgres::getJdbcUrl);
+    }
+
+    @Autowired PedidoRepository repository;
+
+    @Test
+    void dado_pedido_salvo_quando_buscar_por_id_entao_retorna() {
+        Pedido pedido = repository.save(PedidoTestFactory.comUmItem());
+        assertThat(repository.findById(pedido.getId())).isPresent();
+    }
+}
+```
+
+## Nível 3 — Testes E2E (fluxos críticos)
+
+Testam a API completa via HTTP, do controller ao banco.
+
+**Ferramentas:** RestAssured, Testcontainers (banco real)
+
+```java
+@SpringBootTest(webEnvironment = RANDOM_PORT)
+@Testcontainers
+class ConfirmarPedidoE2ETest {
+    @LocalServerPort int port;
+
+    @Test
+    void confirmar_pedido_retorna_200_com_status_confirmado() {
+        String pedidoId = criarPedidoViaApi();
+
+        given()
+            .port(port)
+            .contentType(ContentType.JSON)
+        .when()
+            .post("/pedidos/{id}/confirmar", pedidoId)
+        .then()
+            .statusCode(200)
+            .body("status", equalTo("CONFIRMADO"));
+    }
+}
+```
+
+## Nomenclatura
+
+Padrão: `dado_[contexto]_quando_[acao]_entao_[resultado]`
+
+```
+dado_pedido_com_itens_quando_confirmar_entao_status_confirmado
+dado_usuario_inativo_quando_autenticar_entao_lanca_UsuarioInativoException
+dado_estoque_zerado_quando_reservar_entao_retorna_false
+```
+
+## Cobertura mínima
+
+| Camada          | Cobertura mínima |
+|-----------------|-----------------|
+| `domain`        | 90%             |
+| `application`   | 80%             |
+| `infrastructure`| 60% (integração complementa) |
+
+Configure no `pom.xml` com JaCoCo:
+
+```xml
+<configuration>
+    <rules>
+        <rule>
+            <element>PACKAGE</element>
+            <includes>
+                <include>**.domain.**</include>
+                <include>**.application.**</include>
+            </includes>
+            <limits>
+                <limit>
+                    <counter>LINE</counter>
+                    <minimum>0.80</minimum>
+                </limit>
+            </limits>
+        </rule>
+    </rules>
+</configuration>
+```

package/pscode/content/dixi/context/react/architecture.md

@@ -0,0 +1,119 @@
+# Arquitetura — React/Next.js (Feature-Sliced Design)
+
+## Camadas (de baixo para cima)
+
+```
+pages / app          ← Next.js routes, composição de features
+features             ← unidades funcionais independentes
+entities             ← modelos de negócio reutilizáveis
+shared               ← utilitários, UI base, types globais
+```
+
+Camadas superiores podem importar das inferiores. **Camadas inferiores nunca importam das superiores.**
+
+## Estrutura de pastas
+
+```
+src/
+├── app/                    # Next.js App Router (ou pages/)
+│   ├── layout.tsx
+│   └── checkout/
+│       └── page.tsx        # Apenas composição de features
+├── features/
+│   ├── checkout/           # Feature autocontida
+│   │   ├── components/     # Componentes internos da feature
+│   │   ├── hooks/          # Hooks internos
+│   │   ├── services/       # Chamadas de API da feature
+│   │   ├── types/          # Tipos TypeScript da feature
+│   │   └── index.ts        # Barrel export — única entrada pública
+│   └── auth/
+│       └── index.ts
+├── entities/
+│   ├── product/
+│   │   ├── model.ts        # Tipos e schemas da entidade
+│   │   └── index.ts
+│   └── user/
+│       └── index.ts
+└── shared/
+    ├── ui/                 # Componentes base (Button, Input, Modal)
+    ├── lib/                # Utilitários e helpers
+    ├── api/                # Cliente HTTP base (axios, fetch wrapper)
+    └── types/              # Tipos globais compartilhados
+```
+
+## Regras fundamentais
+
+### No cross-import entre features
+
+Features **não podem importar umas das outras** diretamente:
+
+```typescript
+// ❌ PROIBIDO
+import { useCart } from '../cart'; // feature cart importando de outra feature
+
+// ✅ CORRETO — mova o dado compartilhado para entities
+import { Product } from '@/entities/product';
+```
+
+Se duas features precisam de algo em comum, mova esse algo para `entities` ou `shared`.
+
+### Barrel export como contrato público
+
+Tudo que sai de uma feature deve passar pelo `index.ts`:
+
+```typescript
+// features/checkout/index.ts
+export { CheckoutPage } from './components/CheckoutPage';
+export { useCheckoutForm } from './hooks/useCheckoutForm';
+export type { CheckoutFormData } from './types';
+// Services e hooks internos NÃO são exportados
+```
+
+Externos à feature importam **apenas do barrel**:
+
+```typescript
+// ✅ CORRETO
+import { CheckoutPage } from '@/features/checkout';
+
+// ❌ PROIBIDO — acesso direto a módulo interno
+import { CheckoutPage } from '@/features/checkout/components/CheckoutPage';
+```
+
+### Pages/App são apenas composição
+
+Pages não contêm lógica de negócio — apenas montam features:
+
+```typescript
+// app/checkout/page.tsx
+import { CheckoutPage } from '@/features/checkout';
+import { AuthGuard } from '@/features/auth';
+
+export default function Page() {
+  return (
+    <AuthGuard>
+      <CheckoutPage />
+    </AuthGuard>
+  );
+}
+```
+
+## Quando criar uma nova feature
+
+Crie uma nova feature quando:
+- A funcionalidade tem um domínio claramente delimitado
+- Possui componentes, hooks e serviços próprios
+- Não é reutilizável por natureza (se for reutilizável, considere `entities` ou `shared`)
+
+## Skeleton e guardrails automáticos (profile dixi)
+
+`pscode init --profile dixi` cria automaticamente a estrutura feature-sliced com `.gitkeep` nos diretórios folha e `features/README.md` com as convenções documentadas. Também instala `eslint-architecture.mjs` na raiz com regras `no-restricted-imports` para:
+
+- Isolar features entre si (features não importam umas das outras)
+- Impedir que páginas importem lógica de negócio diretamente
+
+Para ativar as regras no ESLint, adicione ao `eslint.config.js`:
+
+```js
+import architectureRules from './eslint-architecture.mjs';
+export default [...existingConfig, ...architectureRules];
+```

package/pscode/content/dixi/context/react/naming.md

@@ -0,0 +1,129 @@
+# Convenções de Nomenclatura — React/Next.js
+
+## Resumo rápido
+
+| Tipo                  | Convenção          | Exemplos                                     |
+|-----------------------|--------------------|----------------------------------------------|
+| Componente React      | `PascalCase`       | `CheckoutForm`, `UserAvatar`, `ProductCard`  |
+| Hook                  | `use` + PascalCase | `useCheckoutForm`, `useAuth`, `useProductList`|
+| Service / função util | `camelCase`        | `submitCheckout`, `formatCurrency`, `parseDate`|
+| Arquivo de componente | `kebab-case.tsx`   | `checkout-form.tsx`, `user-avatar.tsx`       |
+| Arquivo de hook       | `use-*.ts`         | `use-checkout-form.ts`, `use-auth.ts`        |
+| Arquivo de service    | `*-service.ts`     | `checkout-service.ts`, `auth-service.ts`     |
+| Constante             | `SCREAMING_SNAKE`  | `MAX_ITEMS`, `API_BASE_URL`, `DEFAULT_TIMEOUT`|
+| Tipo / Interface      | `PascalCase`       | `CheckoutFormData`, `UserProfile`, `ApiError`|
+| Enum                  | `PascalCase` (valor `SCREAMING_SNAKE`) | `enum Status { ACTIVE = 'ACTIVE' }` |
+
+## Componentes React
+
+**PascalCase** — sempre.
+
+```typescript
+// ✅ Correto
+export function CheckoutForm() { ... }
+export const UserAvatar: React.FC<Props> = () => { ... }
+
+// ❌ Errado
+export function checkoutForm() { ... }
+export function checkout_form() { ... }
+```
+
+Arquivos de componente em **kebab-case**:
+```
+checkout-form.tsx     ✅
+CheckoutForm.tsx      ❌ (exceto se a convenção do projeto usar PascalCase em arquivos)
+```
+
+## Hooks
+
+`use` + PascalCase. O nome deve descrever o que o hook faz ou gerencia.
+
+```typescript
+// ✅ Correto
+function useCheckoutForm() { ... }
+function useProductList(categoryId: string) { ... }
+function useAuth() { ... }
+
+// ❌ Errado
+function checkoutFormHook() { ... }
+function UseCheckoutForm() { ... }    // PascalCase não é hook
+function useGetProductList() { ... }  // evite "get" — já está implícito
+```
+
+## Services (funções de acesso a API ou lógica assíncrona)
+
+**camelCase** para a função, arquivo em **kebab-case**:
+
+```typescript
+// checkout-service.ts
+export async function submitCheckout(data: CheckoutData): Promise<OrderResponse> { ... }
+export async function fetchCheckoutSummary(cartId: string): Promise<Summary> { ... }
+
+// ❌ Errado
+export async function SubmitCheckout() { ... }     // PascalCase é componente
+export async function submit_checkout() { ... }    // snake_case não é JS/TS
+```
+
+## Constantes
+
+**SCREAMING_SNAKE_CASE** para valores imutáveis de escopo global ou de módulo:
+
+```typescript
+// ✅ Correto
+const MAX_RETRY_ATTEMPTS = 3;
+const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL;
+const DEFAULT_PAGE_SIZE = 20;
+
+// ❌ Errado
+const maxRetryAttempts = 3;    // parece variável local mutável
+const MaxRetryAttempts = 3;    // PascalCase é componente ou tipo
+```
+
+## Tipos e Interfaces
+
+**PascalCase**, com sufixo descritivo quando necessário para clareza:
+
+```typescript
+// ✅ Correto
+type CheckoutFormData = { email: string; items: CartItem[] };
+interface UserProfile { id: string; name: string }
+type ApiError = { code: string; message: string };
+
+// Use sufixos quando o nome base é ambíguo
+type CheckoutRequest = { ... };   // DTO de entrada
+type CheckoutResponse = { ... };  // DTO de saída
+type CheckoutState = { ... };     // estado do componente/hook
+```
+
+## Props de componentes
+
+Sufixo `Props` no tipo:
+
+```typescript
+type CheckoutFormProps = {
+  onSubmit: (data: CheckoutFormData) => void;
+  initialValues?: Partial<CheckoutFormData>;
+};
+
+function CheckoutForm({ onSubmit, initialValues }: CheckoutFormProps) { ... }
+```
+
+## Handlers de eventos
+
+Prefixo `handle` para funções internas; prefixo `on` para props de callback:
+
+```typescript
+// Props (contrato externo)
+type CardProps = {
+  onSelect: (id: string) => void;    // prefixo "on"
+  onDelete: () => void;
+};
+
+// Handlers internos
+function ProductCard({ onSelect }: CardProps) {
+  function handleClick() {           // prefixo "handle"
+    onSelect(product.id);
+  }
+  return <div onClick={handleClick} />;
+}
+```

package/pscode/content/dixi/context/react/testing.md

@@ -0,0 +1,141 @@
+# Testes — React/Next.js
+
+## Pirâmide de testes
+
+```
+         [E2E — Playwright]           ← fluxos críticos de usuário
+       [Componentes — RTL]            ← comportamento visível ao usuário
+   [Unitários — Vitest]               ← hooks, services, utils (maioria)
+```
+
+## Nível 1 — Testes unitários (hooks, services, utils)
+
+Testam lógica pura sem renderizar componentes.
+
+**Ferramenta:** Vitest
+
+**Onde ficam:** ao lado do arquivo testado (`*.test.ts`) ou em `__tests__/`
+
+```typescript
+// features/checkout/hooks/useCheckoutForm.test.ts
+import { renderHook, act } from '@testing-library/react';
+import { useCheckoutForm } from './useCheckoutForm';
+
+describe('useCheckoutForm', () => {
+  it('deve inicializar com campos vazios', () => {
+    const { result } = renderHook(() => useCheckoutForm());
+    expect(result.current.values.email).toBe('');
+  });
+
+  it('deve validar email inválido', async () => {
+    const { result } = renderHook(() => useCheckoutForm());
+    await act(async () => {
+      result.current.setField('email', 'nao-e-email');
+      await result.current.validate();
+    });
+    expect(result.current.errors.email).toBeDefined();
+  });
+});
+```
+
+```typescript
+// features/checkout/services/checkoutService.test.ts
+import { vi, describe, it, expect } from 'vitest';
+import { submitCheckout } from './checkoutService';
+import { apiClient } from '@/shared/api';
+
+vi.mock('@/shared/api');
+
+describe('submitCheckout', () => {
+  it('deve chamar a API com os dados corretos', async () => {
+    const mockPost = vi.mocked(apiClient.post).mockResolvedValue({ data: { orderId: '123' } });
+    const result = await submitCheckout({ email: 'test@test.com', items: [] });
+    expect(mockPost).toHaveBeenCalledWith('/checkout', expect.objectContaining({ email: 'test@test.com' }));
+    expect(result.orderId).toBe('123');
+  });
+});
+```
+
+## Nível 2 — Testes de componentes (React Testing Library)
+
+Testam o comportamento do componente do ponto de vista do usuário, não a implementação.
+
+**Ferramenta:** React Testing Library (RTL) + Vitest
+
+**Princípio:** Consulte elementos como o usuário os veria (por role, label, texto — não por classe CSS ou estrutura interna)
+
+```typescript
+// features/checkout/components/CheckoutForm.test.tsx
+import { render, screen, userEvent } from '@testing-library/react';
+import { CheckoutForm } from './CheckoutForm';
+
+describe('CheckoutForm', () => {
+  it('deve exibir erro quando email está vazio e o form é enviado', async () => {
+    render(<CheckoutForm onSubmit={vi.fn()} />);
+
+    await userEvent.click(screen.getByRole('button', { name: /confirmar/i }));
+
+    expect(screen.getByText(/email é obrigatório/i)).toBeInTheDocument();
+  });
+
+  it('deve chamar onSubmit com dados corretos quando form é válido', async () => {
+    const onSubmit = vi.fn();
+    render(<CheckoutForm onSubmit={onSubmit} />);
+
+    await userEvent.type(screen.getByLabelText(/e-mail/i), 'user@example.com');
+    await userEvent.click(screen.getByRole('button', { name: /confirmar/i }));
+
+    expect(onSubmit).toHaveBeenCalledWith(expect.objectContaining({ email: 'user@example.com' }));
+  });
+});
+```
+
+## Nível 3 — Testes E2E (Playwright)
+
+Testam fluxos críticos de ponta a ponta no browser real.
+
+**Ferramenta:** Playwright
+
+**Onde ficam:** `e2e/` na raiz do projeto
+
+**Escopo:** apenas fluxos críticos de negócio (login, checkout, fluxo principal)
+
+```typescript
+// e2e/checkout.spec.ts
+import { test, expect } from '@playwright/test';
+
+test('usuário consegue completar o checkout', async ({ page }) => {
+  await page.goto('/checkout');
+  await page.getByLabel('E-mail').fill('user@example.com');
+  await page.getByRole('button', { name: 'Confirmar pedido' }).click();
+
+  await expect(page.getByText('Pedido confirmado!')).toBeVisible();
+  await expect(page).toHaveURL(/\/confirmacao/);
+});
+```
+
+## Configuração
+
+```typescript
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: 'jsdom',
+    setupFiles: ['./src/test/setup.ts'],
+    coverage: {
+      reporter: ['text', 'lcov'],
+      exclude: ['**/*.test.*', 'e2e/**', 'src/test/**'],
+    },
+  },
+});
+```
+
+## O que NÃO testar
+
+- Lógica de estilo (CSS, classes) — use Storybook para isso
+- Detalhes de implementação interna (state do componente, refs)
+- Snapshots de componentes complexos — ficam desatualizados rapidamente

package/pscode/content/dixi/context/shared/commits.md

@@ -0,0 +1,47 @@
+# Convenção de Commits
+
+## Formato obrigatório
+
+```
+tipo(escopo): descrição imperativa [PROJ-123]
+```
+
+**Exemplos válidos:**
+```
+feat(pagamento): adicionar integração com gateway PIX [PAY-456]
+fix(auth): corrigir expiração de token JWT [AUTH-789]
+refactor(pedido): extrair lógica de cálculo de frete [ORD-321]
+test(usuario): adicionar testes de integração para cadastro [USR-100]
+docs(readme): atualizar instruções de setup local
+chore(deps): atualizar Spring Boot para 3.2.0
+```
+
+## Tipos válidos
+
+| Tipo       | Quando usar                                        |
+|------------|----------------------------------------------------|
+| `feat`     | Nova funcionalidade                                |
+| `fix`      | Correção de bug                                    |
+| `refactor` | Mudança de código sem alterar comportamento externo|
+| `test`     | Adição ou modificação de testes                    |
+| `docs`     | Documentação apenas                                |
+| `chore`    | Tarefas de manutenção, deps, build, CI             |
+
+## Regras de escopo
+
+O escopo deve corresponder ao módulo, bounded context ou feature afetada.
+
+- Java/Spring: nome do bounded context ou pacote de domínio (ex: `pagamento`, `pedido`, `usuario`)
+- React/Next.js: nome da feature ou camada (ex: `checkout`, `auth`, `shared`)
+
+## Ticket JIRA obrigatório
+
+- **Obrigatório** em todos os commits **exceto** `docs` e `chore`
+- Formato: `[PROJ-NNN]` ao final da primeira linha
+- O ticket deve estar em estado "Em Desenvolvimento" ou "Em Revisão" antes do commit
+
+## Mensagem no imperativo
+
+Use verbos no imperativo: "adicionar", "corrigir", "remover", "atualizar" (não "adicionado", "corrigido").
+
+A mensagem deve completar a frase: *"Se aplicado, este commit vai [mensagem]"*