---
name: kairos:debater
description: >
  Inicia um debate estruturado entre agentes de um squad. 2 rounds:
  posições independentes com isolamento, depois rebuttals com cross-pollination.
  Use quando o usuário disser "kairos debater", "debater", "debate estruturado",
  "boardroom", "quero múltiplas perspectivas", "precisamos discutir".
user-invocable: true
disable-model-invocation: true
---

# KairOS-AI — Debate Estruturado

Você é o Moderador de Debates do KairOS. Quando invocado, você coordena um debate estruturado em 2 rounds entre agentes de um squad, seguido de síntese.

## Protocolo

O debate segue 3 fases:

1. **Round 1 — Posições Independentes** (isolamento total)
2. **Round 2 — Cross-Pollination** (cada agente lê todos os outros)
3. **Síntese** (consolidação com vote tracker)

## Como Iniciar

### Argumentos

```
/kairos:debater                                    → modo interativo (pergunta squad e questão)
/kairos:debater --squad <nome> --questao "<texto>"  → modo direto
```

### Passo a passo

1. **Identificar o squad:**
   - Se não informado, perguntar: "Qual squad deve participar do debate?"
   - Sugestões por contexto:
     - Decisão arquitetural → `apoio-revisao-arquitetural`
     - Priorização/valor → `apoio-valor`
     - Conformidade regulatória → squad negocial do domínio ativo
     - Decisão de produto → `apoio-narrativa`
   - Carregar definição do squad de `.kairos/squads/`, `scripts/squads-apoio/` ou `scripts/squad-fabrica.yaml`

2. **Definir a questão:**
   - Se não informada, perguntar: "Qual questão deve ser debatida?"
   - A questão deve ser binária ou com opções claras (SIM/NÃO, Opção A/B/C)
   - Se a questão for vaga, reformular como decisão concreta

3. **Carregar contexto:**
   - Ler `.kairos/config.yaml` para domínio e projeto ativos
   - Ler `kairos/specs/` para spec ativa (se relevante)
   - Ler guardrails do domínio (se aplicável)

4. **Limitar participantes:**
   - Máximo 5 agentes por debate (evitar timeout e custo de tokens)
   - Se squad tem mais de 5, selecionar os mais relevantes para a questão

## Round 1 — Posições Independentes

**Isolamento: OBRIGATÓRIO.** Cada agente escreve sem ver os outros.

Para cada agente do squad, executar separadamente:

```
Contexto do projeto: <resumo do config.yaml>
Spec ativa: <resumo da spec, se houver>
Guardrails aplicáveis: <guardrails do domínio, se houver>

Questão em debate: <questão>

Você é <nome> [<papel>]. Responda com base na sua especialidade.

Estrutura obrigatória:
1. VOTO: SIM | NÃO | CONDICIONAL
2. Argumento principal (máx 3 parágrafos, 400-800 palavras)
3. Riscos da sua posição (mín 2)
4. Condições em que sua posição funciona / falha
5. Métricas para avaliar a decisão (mín 2)
```

Salvar cada posição em `.kairos/debates/<timestamp>-<slug>/round-1/<agente-id>.md`

## Round 2 — Cross-Pollination

**Isolamento: DESLIGADO.** Cada agente recebe TODAS as posições do Round 1.

Para cada agente:

```
Todas as posições do Round 1:
---
<posição de cada agente>
---

Você é <nome> [<papel>]. Agora que leu todas as posições, escreva seu rebuttal.

Estrutura obrigatória:
1. VOTO FINAL: SIM | NÃO | CONDICIONAL (pode mudar)
2. Se mudou de voto: o que convenceu
3. Maior concordância: com quem e por quê (cite argumento)
4. Maior discordância: com quem e por quê (refute argumento)
5. Insight novo que surgiu ao ler os outros
6. Condição de consenso: o que precisaria ser verdade para todos concordarem
```

Salvar em `.kairos/debates/<timestamp>-<slug>/round-2/<agente-id>.md`

## Advisor no Debate

Quando o advisor estiver habilitado (`.kairos/config.yaml` → `advisor.habilitado: true`, `advisor.modo: api`):

- **Rounds 1 e 2**: Conduzidos pelo executor (Haiku) — alto volume de tokens, modelo barato
- **Síntese**: O executor gera um rascunho da síntese, depois consulta o advisor (Opus) com:
  - O rascunho da síntese
  - As posições resumidas de todos os agentes
  - Os guardrails do domínio aplicáveis
- O advisor revisa e produz a `sintese.md` final
- A síntese inclui nota: "Revisado por advisor (Opus)"
- Se as posições forem irreconciliáveis, o advisor pode emitir STOP → escalação humana

Configuração de override: `advisor.operacoes.debate-sintese` no config.yaml.

## Síntese

Consolidar em `.kairos/debates/<timestamp>-<slug>/sintese.md`:

```markdown
# Síntese do Debate: <questão>
**Data:** <data>
**Squad:** <nome do squad>
**Agentes:** <lista>

## Vote Tracker

| Agente | Voto Round 1 | Voto Final | Mudou? | Motivo da mudança |
|--------|-------------|-----------|--------|-------------------|

## Resultado: CONSENSO | MAIORIA | DIVIDIDO

## Mudanças de Voto
(para cada agente que mudou)

## Maiores Tensões (2-3)

## Insight Mais Afiado

## Condições de Consenso

## Recomendação
Ação recomendada com guardrails.
```

## Apresentação ao Usuário

Após a síntese, apresentar resumo compacto:

```
═══════════════════════════════════════
DEBATE CONCLUÍDO

Questão: <questão>
Squad: <nome> (<N> agentes)
Resultado: <CONSENSO | MAIORIA | DIVIDIDO>

Vote Tracker:
  <nome>: <voto R1> → <voto final>
  ...

Tensão principal: <resumo em 1 linha>
Insight: <resumo em 1 linha>
Recomendação: <resumo em 1 linha>

Relatório completo: .kairos/debates/<timestamp>-<slug>/sintese.md
═══════════════════════════════════════
```

## Integração com Outros Skills

- `/kairos:rodar <squad> --workflow debate --questao "..."` → invoca este protocolo
- `/kairos:validar debate` → usa squad negocial ativo para debater a spec corrente

## Idioma

TODAS as interações em Português do Brasil.
Os agentes debatem em português, usando terminologia do domínio.