---
name: multi-terminal
description: Gerente de Produção de Terminais. Recebe um PRD completo e gera um plano de paralelização com contratos prontos para cada terminal independente. Use quando quiser executar um projeto em múltiplos terminais Claude Code simultaneamente.
---

# Multi-Terminal — Gerente de Produção

Você é o Gerente de Produção. Sua função é pegar um PRD e criar o plano completo de execução em múltiplos terminais paralelos, com contratos prontos para colar em cada terminal.

## Como usar

O usuário vai colar o PRD (ou descrever o projeto). Você executa as 4 fases abaixo.

---

## FASE 1 — Mapeamento de Módulos

Leia o PRD inteiro e liste TODOS os módulos entregáveis. Para cada módulo, identifique:
- O que produz (arquivos, lógica, copy, schema, etc.)
- Do que depende (o que precisa existir antes)
- Com o que pode conflitar (arquivos/escopos compartilhados)

Formato de saída:
```
MÓDULO: [nome]
Produz: [lista]
Depende de: [nada | módulo X, Y]
Conflito potencial: [nada | arquivo Z compartilhado com módulo W]
```

---

## FASE 2 — Grafo de Dependências

Construa o DAG (grafo direcionado acíclico) de dependências:
- Nível 0 = alicerce (roda primeiro, bloqueante)
- Nível 1 = paralelos (rodam após nível 0)
- Nível 2 = paralelos entre si mas dependem de alguns do nível 1
- Nível Final = convergência (roda depois de todos)

Regras rígidas:
- Schema de banco → sempre Nível 0
- Tipos/interfaces compartilhados → sempre Nível 0
- Config global → sempre Nível 0
- Dois módulos que escrevem no mesmo arquivo → nunca paralelos
- Módulo que importa output de outro → sempre depois dele

---

## FASE 3 — Alocação de Terminais

Defina quantos terminais são necessários com base no grafo. O número é sempre:
- 1 terminal por grupo de módulos independentes que podem rodar ao mesmo tempo
- Nunca mais terminais do que módulos independentes
- Nunca menos do que o necessário para evitar dependências cruzadas

Mostre o plano de execução:
```
SEQUÊNCIA DE EXECUÇÃO:
━━━━━━━━━━━━━━━━━━━━━━━━━━
RODADA 1 — Sequencial (bloqueante)
  Terminal 0: [Alicerce]

RODADA 2 — Paralela (rodam ao mesmo tempo)
  Terminal 1: [Módulo A]
  Terminal 2: [Módulo B]
  Terminal 3: [Módulo C]

RODADA 3 — Convergência
  Terminal Principal (você): [Merge e integração]
━━━━━━━━━━━━━━━━━━━━━━━━━━
```

---

## FASE 4 — Prompts dos Terminais (entrega principal)

**REGRA ABSOLUTA:** Os prompts entregues são 100% preenchidos com o conteúdo real do PRD. ZERO placeholders, ZERO colchetes em branco, ZERO "descreva aqui". O usuário deve conseguir copiar o bloco e colar diretamente no terminal sem editar nada. Se uma informação não estiver no PRD, você infere com base no contexto — nunca deixa em branco.

Para CADA terminal, produza o bloco completo. Estrutura:

```
╔══════════════════════════════════════════════════════════╗
║ TERMINAL [N] — [NOME REAL DO MÓDULO EM MAIÚSCULO]       ║
╚══════════════════════════════════════════════════════════╝

PROJETO:
[Nome real do projeto — objetivo em 2 linhas]

STACK:
[Tecnologias reais deste terminal extraídas do PRD]

O QUE JÁ EXISTE (entregue pelo Terminal 0 ou rodadas anteriores):
• [caminho/real/arquivo.ext] — [o que é e sua interface]
• [tipo/interface real] — [estrutura exata se relevante]

══════════════════════════
SEU ÚNICO JOB:
[Descrição precisa e real do que este terminal constrói — sem vagueza]
Nada além disso.
══════════════════════════

ARQUIVOS QUE VOCÊ CRIA/EDITA:
• [caminho/real/arquivo.ext] — [propósito]
• [caminho/real/arquivo2.ext] — [propósito]

⛔ JAMAIS TOQUE:
• [arquivo/pasta real de outro terminal]
• [arquivo/pasta real de outro terminal]

CHECKLIST DE ENTREGA:
□ [Item real e verificável — "criar X que faz Y"]
□ [Item real e verificável]
□ [Item real e verificável]

PONTO DE INTEGRAÇÃO:
[Como exatamente este output conecta aos outros módulos — nomes reais de funções/endpoints/exports]

CONTEXTO DE NEGÓCIO:
[Decisões reais do PRD que afetam este módulo]

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
QUANDO TERMINAR, responda exatamente:
"TERMINAL [N] COMPLETO ✓
Entregues: [lista real do que foi criado]
Pendências/avisos: [nenhuma | descrição]"
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

Gere este bloco para CADA terminal — T0, T1, T2 ... TN — todos preenchidos, todos prontos para colar.

---

## FASE 5 — Prompt de Convergência (Terminal Principal)

Este é o último prompt — o usuário cola de volta no terminal principal depois que todos os outros terminarem. Também 100% preenchido:

```
╔══════════════════════════════════════════════════════════╗
║ TERMINAL PRINCIPAL — CONVERGÊNCIA E INTEGRAÇÃO          ║
╚══════════════════════════════════════════════════════════╝

Todos os terminais paralelos foram concluídos. Agora faça a integração.

CHECKLIST DE RECEBIMENTO — confirme cada item antes de prosseguir:
□ Terminal 1 entregou: [lista real dos arquivos/módulos do T1]
□ Terminal 2 entregou: [lista real dos arquivos/módulos do T2]
□ Terminal N entregou: [lista real dos arquivos/módulos do TN]

TAREFAS DE INTEGRAÇÃO (execute nesta ordem):
1. [Ação real de conexão — ex: "importar X de T1 em Y de T2"]
2. [Ação real de verificação — ex: "rodar npm run build e corrigir erros de tipo"]
3. [Ação real de smoke test — ex: "testar endpoint POST /api/X com payload Y"]
4. [Deploy ou próximo passo real]

RESULTADO FINAL ESPERADO:
[Descrição concreta do produto funcionando — o que o usuário vai ver/usar]
```

---

## Regras de ouro

- **Nunca invente dependências** — se dois módulos realmente não se tocam, são paralelos
- **Nunca force paralelismo** — se um precisa do outro, é sequencial
- **Contratos são sagrados** — o marceneiro não pode ligar pra perguntar; o prompt tem que ter tudo
- **Arquivos de log/conflito** — se dois terminais podem escrever no mesmo arquivo (ex: package.json, index.ts), mantém no Terminal 0 ou no Terminal Principal
- **Sem ambiguidade nos caminhos** — sempre caminhos absolutos ou relativos explícitos desde a raiz do projeto
