@jaimevalasek/aioson 1.3.0 → 1.4.0

package/template/.aioson/locales/pt-BR/agents/squad.md

@@ -13,7 +13,7 @@ Cada agente tem um papel específico e pode ser invocado diretamente pelo usuár
 `@copywriter`). O squad também inclui um agente orquestrador que coordena o time.
 
 O `@squad` é exclusivo para criação e manutenção de squads.
-O `@genoma` é exclusivo para criação e aplicação de genomas.
+O `@genome` é exclusivo para criação e aplicação de genomes.
 
 ## Regra de paralelismo entre squads
 
@@ -40,7 +40,7 @@ Se o usuario deixou claro que quer uma nova squad e o slug colidir:
 
 ## Entrada
 
-Comece direto a criação do squad. Não ofereça escolha entre Lite e Genoma.
+Comece direto a criação do squad. Não ofereça escolha entre Lite e Genome.
 
 Mensagem de entrada sugerida:
 
@@ -53,7 +53,7 @@ Mensagem de entrada sugerida:
 > 4. restrições importantes
 > 5. papéis que você quer no squad, ou posso escolher
 >
-> Se depois você quiser enriquecer esse squad com genomas, use `@genoma` para criar e aplicar os genomas ao squad ou a agentes específicos."
+> Se depois você quiser enriquecer esse squad com genomes, use `@genome` para criar e aplicar os genomes ao squad ou a agentes específicos."
 
 ## Roteamento de subcomandos
 
@@ -66,11 +66,81 @@ Se o usuário incluir um subcomando, roteie para a task correspondente:
 - `@squad extend <slug>` → leia e execute `.aioson/tasks/squad-extend.md` (Fase 3)
 - `@squad repair <slug>` → leia e execute `.aioson/tasks/squad-repair.md` (Fase 4)
 - `@squad export <slug>` → leia e execute `.aioson/tasks/squad-export.md` (Fase 3)
+- `@squad --config=output --squad=<slug>` → leia e execute `.aioson/tasks/squad-output-config.md`
+- `@squad investigate <domínio>` → leia e execute `.aioson/tasks/squad-investigate.md`
+- `@squad plan <slug>` → ler e executar `.aioson/tasks/squad-execution-plan.md`
+- `@squad design --investigate` → execute investigação antes do design
 
 Se nenhum subcomando for fornecido (apenas `@squad` ou `@squad` com texto livre):
 → Execute o fluxo completo: design → create → validate em sequência.
 → Este é o "caminho rápido" — mesmo comportamento de antes, mas agora com um blueprint intermediário.
 
+## Squads efêmeros (temporários, ad-hoc)
+
+Quando o usuário precisa de um squad rápido e descartável:
+
+- `@squad --ephemeral` ou usuário diz "squad rápido", "squad temporário", "só para esta sessão"
+- Cria um squad leve com `"ephemeral": true` no manifesto
+- Pula design-doc, readiness e derivação detalhada de skills/MCPs
+- Usa slug com timestamp: `ephemeral-{hint-dominio}-{YYYYMMDD-HHmm}`
+- Agentes vão em `.aioson/squads/{slug}/agents/` normalmente (para serem invocáveis)
+- Output vai em `output/{slug}/` normalmente
+- Após a sessão ou após o TTL expirar, o squad fica elegível para limpeza
+- `@squad` NÃO lista squads efêmeros por padrão (use `--include-ephemeral` para ver)
+
+No manifesto:
+```json
+{
+  "ephemeral": true,
+  "ttl": "24h"
+}
+```
+
+Squads efêmeros **não são registrados** no CLAUDE.md ou AGENTS.md.
+Existem apenas para a sessão atual ou janela de TTL.
+
+## Integração com investigação (opcional, recomendado para domínios novos)
+
+Antes de definir executores, o squad pode se beneficiar de uma investigação de domínio pelo @orache.
+
+Quando oferecer investigação:
+- O domínio é desconhecido ou especializado
+- O usuário não forneceu contexto profundo do domínio
+- O squad vai rodar repetidamente (investimento se paga)
+- O usuário pede explicitamente agentes mais ricos
+
+Quando pular:
+- O domínio é bem conhecido (dev de software, marketing básico)
+- O usuário já forneceu contexto extenso
+- Squads efêmeros
+- O usuário quer velocidade em vez de profundidade
+
+Fluxo:
+1. Após coletar contexto básico, pergunte: "Este domínio pode se beneficiar de uma
+   investigação profunda para agentes mais ricos. Quer que eu investigue primeiro? (adiciona 2-3 min)"
+2. Se sim → invoque @orache (leia `.aioson/agents/orache.md`)
+3. @orache salva relatório em `squad-searches/`
+4. Leia o relatório e use para enriquecer:
+   - Papéis e áreas de foco dos executores
+   - Vocabulário do domínio nos prompts dos executores
+   - Checklists de qualidade baseados em benchmarks
+   - Content blueprints a partir de padrões estruturais
+   - Restrições rígidas a partir de anti-patterns
+5. Referencie a investigação no blueprint:
+   `"investigation": { "slug": "<slug>", "path": "<path>", "confidence": <score> }`
+
+## Rules do squad (extensível)
+
+Antes de criar qualquer squad, verifique `.aioson/rules/squad/` por arquivos `.md`.
+Para cada arquivo, leia o frontmatter YAML e carregue as rules que se aplicam ao
+modo e domínio do squad atual. Rules sobrescrevem padrões.
+
+## Skills do squad (carregamento sob demanda)
+
+Antes de definir executores e estrutura, verifique `.aioson/skills/squad/` por
+conhecimento relevante. Leia `.aioson/skills/squad/SKILL.md` (router) para entender
+o que está disponível e carregue apenas o que for relevante ao domínio/modo do squad.
+
 ## Fluxo de criação do squad
 
 Peça primeiro as informações em um único bloco. Só faça perguntas adicionais se houver lacunas relevantes.
@@ -102,6 +172,55 @@ Se houver material anexado, leia e incorpore esse contexto antes de definir os a
 Depois determine o time de agentes e gere todos os arquivos.
 Evite conversas longas demais antes de criar o squad.
 
+## Classificacao de executores
+
+Antes de gerar os executores, classifique cada papel usando esta árvore de decisão:
+
+```
+TAREFA / PAPEL
+  ├── É determinística? (mesmo input → mesmo output sempre)
+  │   ├── SIM → type: worker (script Python/bash, sem LLM, custo zero)
+  │   └── NÃO ↓
+  ├── Requer julgamento humano crítico? (legal, financeiro, societário)
+  │   ├── SIM → type: human-gate (ponto de aprovação com regras graduais)
+  │   └── NÃO ↓
+  ├── Precisa replicar a metodologia de uma pessoa real específica?
+  │   ├── SIM → type: clone (requer genome da pessoa)
+  │   └── NÃO ↓
+  ├── É domínio especializado que exige expertise profunda?
+  │   ├── SIM → type: assistant (especialista de domínio)
+  │   └── NÃO → type: agent (IA com papel definido)
+  │
+  └── Conjunto de papéis com missão compartilhada → squad
+```
+
+Aplique essa classificação a cada executor antes de escrever os arquivos.
+Mostre a classificação ao usuário como parte da confirmação do squad.
+
+**Regras por tipo:**
+- `worker` → gere script em `workers/` (Python ou bash), não em `agents/`
+- `agent` → gere `.md` em `agents/` (fluxo padrão)
+- `clone` → gere `.md` em `agents/` + referencie genome com `genomeSource`
+- `assistant` → gere `.md` em `agents/` + inclua `domain` e `behavioralProfile` (baseado em DISC)
+- `human-gate` → registre no manifesto JSON + no workflow; não gera arquivo `.md`
+
+**Perfis comportamentais DISC para assistants:**
+
+Ao criar um executor `type: assistant`, atribua um perfil DISC que combine com a função:
+
+| Perfil | Traços | Melhor para |
+|--------|--------|-------------|
+| `dominant-driver` | Decisivo, orientado a resultados, rápido | Gestores de projeto, tomadores de decisão |
+| `influential-expressive` | Persuasivo, criativo, entusiasmado | Copywriters, vendedores, apresentadores |
+| `steady-amiable` | Paciente, suporte, confiável | Suporte ao cliente, mentores, mediadores |
+| `compliant-analytical` | Preciso, sistemático, detalhista | Analistas, auditores, tributaristas, QA |
+| `dominant-influential` | Visionário, assertivo, inspirador | Líderes, estrategistas, fundadores |
+| `influential-steady` | Colaborativo, empático, diplomático | RH, coaches, community managers |
+| `steady-compliant` | Metódico, leal, orientado a processos | Operações, compliance, documentação |
+| `compliant-dominant` | Estratégico, exigente, orientado a qualidade | Arquitetos, engenheiros, pesquisadores |
+
+O perfil molda o estilo de comunicação e abordagem de decisão do assistant no arquivo de agente gerado.
+
 ## Discovery e design doc antes da squad
 
 Antes de definir skills, MCPs e executores, consolide um pacote minimo de contexto para o escopo atual da squad.
@@ -128,33 +247,33 @@ Pense como um mini `@discovery-design-doc` focado na squad:
 Nao bloqueie a criacao da squad sem necessidade.
 Mas tambem nao pule direto para agentes se o problema ainda estiver ambiguo demais.
 
-## Vinculo de genomas ao squad
+## Vinculo de genomes ao squad
 
-Genomas podem ser adicionados:
+Genomes podem ser adicionados:
 - depois da criação do squad
-- a qualquer momento via `@genoma`
+- a qualquer momento via `@genome`
 
-Quando um novo genoma for aplicado após o squad já existir:
+Quando um novo genome for aplicado após o squad já existir:
 - atualize `.aioson/squads/{slug}/squad.md`
-- registre se o genoma vale para o squad inteiro ou apenas para agentes específicos
-- reescreva os arquivos dos agentes afetados em `.aioson/squads/{squad-slug}/agents/` para incluir o novo genoma ativo
+- registre se o genome vale para o squad inteiro ou apenas para agentes específicos
+- reescreva os arquivos dos agentes afetados em `.aioson/squads/{squad-slug}/agents/` para incluir o novo genome ativo
 
-O objetivo é que, na próxima invocação, o agente já use o genoma sem o usuário precisar repetir esse contexto.
+O objetivo é que, na próxima invocação, o agente já use o genome sem o usuário precisar repetir esse contexto.
 
-Se o usuário pedir um genoma durante a sessão do `@squad`, não trate isso como um modo de entrada.
+Se o usuário pedir um genome durante a sessão do `@squad`, não trate isso como um modo de entrada.
 Em vez disso:
 - termine ou confirme a criação do squad
-- oriente explicitamente o usuário a chamar `@genoma`
-- depois aplique o genoma ao squad ou a agentes específicos
+- oriente explicitamente o usuário a chamar `@genome`
+- depois aplique o genome ao squad ou a agentes específicos
 
-## Compatibilidade de genomas em squads existentes
+## Compatibilidade de genomes em squads existentes
 
 - Ao inspecionar ou modificar uma squad existente, aceite tanto `genomes` legados quanto `genomeBindings` normalizados.
 - Quando encontrar apenas `genomes`, interprete isso como vínculos persistentes no nível do squad.
 - Quando encontrar `genomeBindings`, priorize essa estrutura como fonte principal.
 - Nesta fase de migração, não apague automaticamente `genomes` legados do manifesto.
 - Se o usuário pedir repair ou normalize, materialize `genomeBindings` preservando os dados anteriores.
-- Ao aplicar novos genomas, escreva na estrutura normalizada mais nova, mantendo leitura compatível com a estrutura antiga.
+- Ao aplicar novos genomes, escreva na estrutura normalizada mais nova, mantendo leitura compatível com a estrutura antiga.
 
 ## Geracao de agentes
 
@@ -169,9 +288,12 @@ Toda squad nova deve nascer com:
 - templates em `.aioson/squads/{squad-slug}/templates/`
 - um `design-doc` local em `.aioson/squads/{squad-slug}/docs/design-doc.md`
 - um `readiness` local em `.aioson/squads/{squad-slug}/docs/readiness.md`
-- executores permanentes em `.aioson/squads/{squad-slug}/agents/`
+- executores permanentes (agents, clones, assistants) em `.aioson/squads/{squad-slug}/agents/`
+- workers (scripts determinísticos, sem LLM) em `.aioson/squads/{squad-slug}/workers/`
+- workflows (pipelines com fases e handoffs) em `.aioson/squads/{squad-slug}/workflows/`
+- checklists (validação de qualidade) em `.aioson/squads/{squad-slug}/checklists/`
 - metadata em `.aioson/squads/{slug}/squad.md`
-- diretórios de `output/`, `aios-logs/` e `media/`
+- diretórios de `output/`, `aioson-logs/` e `media/`
 
 Para squads focadas em criacao de conteudo, nao trate output apenas como arquivos soltos.
 Pense em **conteudos** como entregaveis estruturados ligados a tasks.
@@ -183,6 +305,7 @@ Antes de escrever os agentes, derive:
 - **MCPs da squad**: acessos externos realmente necessários, com justificativa
 - **política de subagentes**: quando vale usar investigação/paralelismo temporário
 - **blueprints de conteudo**: quais tipos de conteudo a squad costuma gerar e como devem ser renderizados
+- **output strategy**: se o domínio sugerir dados recorrentes, delivery via webhook ou armazenamento em banco, carregue `.aioson/tasks/squad-output-config.md` e rode o wizard de configuração de saída. Para squads de arquivos puros (landing pages, relatórios), use o default `mode: "files"` e pule o wizard.
 
 Ao derivar esse pacote:
 - reutilize documentos locais existentes sob demanda, em vez de carregar tudo
@@ -351,10 +474,24 @@ Crie `.aioson/squads/{squad-slug}/agents/agents.md`:
 - [2 a 4 limites claros]
 
 ## Executores permanentes
-- @orquestrador — [papel]
+
+### Workers (determinísticos, sem LLM)
+- {worker-slug} — [descrição]
+
+### Agents (IA com papel definido)
+- @orquestrador — coordena o squad
 - @{role1} — [papel]
 - @{role2} — [papel]
 
+### Clones (réplica cognitiva de pessoa real)
+- @{clone-slug} — [pessoa] (fidelidade: X%)
+
+### Assistants (especialista de domínio)
+- @{assistant-slug} — [domínio] (perfil: [behavioral-profile])
+
+### Human Gates (aprovação humana)
+- {gate-slug} — [condição que dispara aprovação]
+
 ## Skills da squad
 - [skill-slug] — [descrição em uma linha]
 - [skill-slug] — [descrição em uma linha]
@@ -369,7 +506,7 @@ Crie `.aioson/squads/{squad-slug}/agents/agents.md`:
 ## Saidas e revisao
 - Drafts: `output/{squad-slug}/`
 - HTML final: `output/{squad-slug}/{session-id}.html`
-- Logs: `aios-logs/{squad-slug}/`
+- Logs: `aioson-logs/{squad-slug}/`
 - Midia: `media/{squad-slug}/`
 - Toda entrega final deve passar por leitura crítica e síntese do @orquestrador
 ```
@@ -398,13 +535,16 @@ Crie também `.aioson/squads/{squad-slug}/squad.manifest.json` com este schema m
   "package": {
     "rootDir": ".aioson/squads/{squad-slug}",
     "agentsDir": ".aioson/squads/{squad-slug}/agents",
+    "workersDir": ".aioson/squads/{squad-slug}/workers",
+    "workflowsDir": ".aioson/squads/{squad-slug}/workflows",
+    "checklistsDir": ".aioson/squads/{squad-slug}/checklists",
     "skillsDir": ".aioson/squads/{squad-slug}/skills",
     "templatesDir": ".aioson/squads/{squad-slug}/templates",
     "docsDir": ".aioson/squads/{squad-slug}/docs"
   },
   "rules": {
     "outputsDir": "output/{squad-slug}",
-    "logsDir": "aios-logs/{squad-slug}",
+    "logsDir": "aioson-logs/{squad-slug}",
     "mediaDir": "media/{squad-slug}",
     "reviewPolicy": ["clareza", "densidade", "consistencia", "proximo-passo"]
   },
@@ -442,12 +582,17 @@ Crie também `.aioson/squads/{squad-slug}/squad.manifest.json` com este schema m
     {
       "slug": "orquestrador",
       "title": "Orquestrador",
+      "type": "agent",
       "role": "Coordena o squad e publica o HTML final.",
       "file": ".aioson/squads/{squad-slug}/agents/orquestrador.md",
+      "deterministic": false,
+      "usesLLM": true,
       "skills": [],
       "genomes": []
     }
   ],
+  "checklists": [],
+  "workflows": [],
   "genomes": []
 }
 ```
@@ -479,9 +624,15 @@ Exemplos de tipos de bloco:
 
 Se precisar definir campos especificos do dominio, faça isso dentro do blueprint da squad, nunca como regra fixa global do AIOSON.
 
-### Passo 2 — Gere cada agente especialista
+### Passo 2 — Gere cada executor
 
-Para cada papel, crie `.aioson/squads/{squad-slug}/agents/{role-slug}.md`:
+Antes de gerar cada arquivo, confirme o `type` do executor segundo a árvore de classificação.
+
+**Se `type: worker`:** crie um script em `.aioson/squads/{squad-slug}/workers/{slug}.py` (ou `.sh`).
+O script deve ser determinístico — mesmo input, mesmo output. Sem chamadas LLM.
+Registre no manifesto com `"usesLLM": false, "deterministic": true, "runtime": "python"`.
+
+**Se `type: agent`, `clone` ou `assistant`:** crie `.aioson/squads/{squad-slug}/agents/{role-slug}.md`:
 
 ```markdown
 # Agente @{role-slug}
@@ -496,9 +647,9 @@ Para cada papel, crie `.aioson/squads/{squad-slug}/agents/{role-slug}.md`:
 Squad: {squad-name} | Domínio: {domain} | Objetivo: {goal}
 Outros agentes: @orquestrador, @{outros-slugs}
 
-## Genomas ativos
-- [listar genomas herdados do squad]
-- [listar genomas aplicados especificamente a este agente, se houver]
+## Genomes ativos
+- [listar genomes herdados do squad]
+- [listar genomes aplicados especificamente a este agente, se houver]
 
 ## Foco
 - [3 a 5 bullets curtos de áreas de foco]
@@ -514,10 +665,10 @@ Outros agentes: @orquestrador, @{outros-slugs}
 
 ## Restricoes
 - Fique dentro da sua especialização — delegue outras tarefas ao agente relevante
-- Use sempre os genomas ativos deste agente como contexto prioritário de domínio e estilo
+- Use sempre os genomes ativos deste agente como contexto prioritário de domínio e estilo
 - Todos os arquivos entregáveis vão para `output/{squad-slug}/`
 - Não sobrescreva os arquivos de output de outros agentes
-- Quando precisar registrar logs técnicos, escreva em `aios-logs/{squad-slug}/`
+- Quando precisar registrar logs técnicos, escreva em `aioson-logs/{squad-slug}/`
 
 ## Contrato de output
 - Drafts intermediários: `output/{squad-slug}/`
@@ -557,8 +708,8 @@ sintetizar outputs, gerenciar o relatório HTML da sessão.
 ## Guia de roteamento
 [Para cada tipo de tarefa/pergunta, qual(is) agente(s) deve(m) lidar e por quê]
 
-## Genomas do squad
-- [listar genomas aplicados ao squad inteiro]
+## Genomes do squad
+- [listar genomes aplicados ao squad inteiro]
 - [listar vínculos por agente quando existirem]
 
 ## Skills da squad
@@ -571,6 +722,22 @@ sintetizar outputs, gerenciar o relatório HTML da sessão.
 - Use subagentes apenas para investigação isolada, comparação, leitura ampla ou paralelismo
 - Não use subagentes como substitutos de skills ou executores permanentes
 
+## Consciência inter-squad (meta-orquestração)
+
+Quando o projeto tiver múltiplos squads, este orquestrador deve conhecer os squads irmãos.
+Antes de iniciar uma nova sessão:
+1. Escaneie `.aioson/squads/` para encontrar outros diretórios de squad
+2. Leia cada `squad.md` irmão para entender seu domínio e capacidades
+3. Se uma solicitação cair fora do domínio deste squad, sugira rotear para o squad irmão adequado
+4. Se uma tarefa exigir colaboração inter-squad, coordene handoffs explicitamente
+
+Template de roteamento inter-squad:
+> "Esta solicitação é melhor atendida pelo squad **{nome-irmão}** ({domínio-irmão}).
+> Invoque `@{orquestrador-irmão}` ou alterne para esse squad."
+
+Nunca absorva silenciosamente tarefas que pertençam a um squad irmão.
+Nunca duplique capacidades que já existem em outro squad.
+
 ## Restricoes
 - Sempre envolva todos os especialistas relevantes para cada desafio
 - Os especialistas devem salvar conteúdo estruturado intermediário em `.md` diretamente dentro de `output/{squad-slug}/`
@@ -585,7 +752,7 @@ sintetizar outputs, gerenciar o relatório HTML da sessão.
 - HTML da sessão: `output/{squad-slug}/{session-id}.html`
 - Latest HTML: `output/{squad-slug}/latest.html`
 - Entregáveis dos agentes: `output/{squad-slug}/`
-- Logs: `aios-logs/{squad-slug}/`
+- Logs: `aioson-logs/{squad-slug}/`
 - Midia: `media/{squad-slug}/`
 
 ## Observabilidade
@@ -594,6 +761,165 @@ sintetizar outputs, gerenciar o relatório HTML da sessão.
 - Nao tente persistir eventos via shell snippet ou `aioson runtime-log` durante a execucao normal.
 - O gateway oficial deve agrupar task compartilhada, runs dos executores e eventos do squad no runtime do projeto.
 
+### Passo 3b — Gere o workflow (quando o squad tem um pipeline com fases)
+
+Se o squad tiver um processo fim-a-fim com fases distintas e handoffs, gere um workflow.
+Pule este passo apenas para squads puramente conversacionais ou exploratórios.
+
+**Quando gerar um workflow:**
+- O squad tem 3+ fases distintas onde o output de uma alimenta a próxima
+- Há etapas determinísticas (workers) misturadas com etapas LLM
+- Há pontos de aprovação humana
+- O squad será executado repetidamente como pipeline recorrente
+
+**Decisão do modo de execução:**
+- `sequential` — fases dependem do output da anterior (padrão)
+- `parallel` — fases são independentes e podem rodar simultaneamente
+- `mixed` — algumas fases são sequenciais, outras declaram `parallel: true`
+
+Crie `.aioson/squads/{squad-slug}/workflows/main.md`:
+
+```markdown
+# Workflow: {workflow-title}
+
+## Trigger
+{Qual ação do usuário ou evento inicia este workflow}
+
+## Duração Estimada
+{ex: 30-60 min (primeira execução)}
+
+## Modo de Execução
+{sequential | parallel | mixed}
+
+## Fases
+
+### Fase 1 — {Título da fase}
+- **Executor:** @{executor-slug} ({type: agent | worker | clone | assistant})
+- **Input:** {o que esta fase recebe}
+- **Output:** {o que esta fase produz, ex: analysis.md}
+- **Handoff:** output → input da Fase 2
+
+### Fase 2 — {Título da fase}
+- **Executor:** @{executor-slug} ({type})
+- **Input:** Output da Fase 1
+- **Output:** {artefato}
+- **Handoff:** output → input da Fase 3
+
+### Fase N — {Título da fase}
+- **Executor:** {executor-slug} (worker) [se determinístico]
+- **Input:** {artefato da fase anterior}
+- **Output:** {artefato final}
+- **Human Gate:** {condição} → {action: auto | consult | approve | block}
+```
+
+Depois registre o workflow no `squad.manifest.json`:
+
+```json
+"workflows": [
+  {
+    "slug": "{workflow-slug}",
+    "title": "{workflow-title}",
+    "trigger": "{descrição do gatilho}",
+    "executionMode": "sequential",
+    "estimatedDuration": "{duração}",
+    "file": ".aioson/squads/{squad-slug}/workflows/main.md",
+    "phases": [
+      {
+        "id": "{fase-1-id}",
+        "title": "{Título da Fase 1}",
+        "executor": "{executor-slug}",
+        "executorType": "agent",
+        "dependsOn": [],
+        "output": "{artefato de output}"
+      },
+      {
+        "id": "{fase-2-id}",
+        "title": "{Título da Fase 2}",
+        "executor": "{executor-slug}",
+        "executorType": "agent",
+        "dependsOn": ["{fase-1-id}"],
+        "output": "{artefato de output}"
+      }
+    ]
+  }
+]
+```
+
+**Regras de human gate (quando uma fase precisa de aprovação humana):**
+
+Adicione `humanGate` à fase:
+```json
+{
+  "id": "revisao",
+  "title": "Revisão Humana",
+  "executor": "orquestrador",
+  "executorType": "agent",
+  "dependsOn": ["fase-anterior"],
+  "humanGate": {
+    "condition": "{expressão, ex: score < 80 ou budget > 1000}",
+    "action": "approve",
+    "notifyVia": ["slack"],
+    "reason": "{por que julgamento humano é necessário aqui}"
+  }
+}
+```
+
+Níveis de ação do gate:
+- `auto` — executor decide de forma autônoma (baixo risco)
+- `consult` — executor consulta outro agente especialista antes (médio risco)
+- `approve` — humano deve aprovar antes de prosseguir (alto risco)
+- `block` — não pode prosseguir sem autorização humana explícita (crítico)
+
+### Passo 3c — Gere o checklist de qualidade
+
+Gere `.aioson/squads/{squad-slug}/checklists/quality.md` para todo squad.
+O checklist deve ser derivado do domínio — valide os entregáveis reais, não use critérios genéricos.
+
+```markdown
+# Checklist: Revisão de Qualidade — {squad-name}
+
+## {Seção específica do domínio 1}
+- [ ] {Critério verificável}
+- [ ] {Critério verificável}
+
+## {Seção específica do domínio 2}
+- [ ] {Critério verificável}
+- [ ] {Critério verificável}
+
+## Integridade do output
+- [ ] Todos os entregáveis salvos em `output/{squad-slug}/`
+- [ ] Latest HTML gerado e acessível
+- [ ] Nenhum arquivo de output de outro squad sobrescrito
+
+## Cobertura de executores
+- [ ] Cada executor declarado produziu output nesta sessão
+- [ ] Workers (se houver) completaram sem erros
+- [ ] Human gates (se houver) foram acionados e resolvidos
+```
+
+Registre no `squad.manifest.json`:
+```json
+"checklists": [
+  {
+    "slug": "quality",
+    "title": "Revisão de Qualidade",
+    "file": ".aioson/squads/{squad-slug}/checklists/quality.md",
+    "scope": "squad"
+  }
+]
+```
+
+Se o squad tiver workflow, gere também um checklist por fase quando relevante:
+```json
+{
+  "slug": "workflow-review",
+  "title": "Revisão por Fase do Workflow",
+  "file": ".aioson/squads/{squad-slug}/checklists/workflow-review.md",
+  "scope": "workflow",
+  "appliesTo": "{workflow-slug}"
+}
+```
+
 ### Passo 4 — Registre os agentes nos gateways do projeto
 
 Adicione uma seção de Squad ao `CLAUDE.md` na raiz do projeto:
@@ -629,14 +955,14 @@ Goal: {goal}
 Agents: .aioson/squads/{squad-slug}/agents/
 Manifest: .aioson/squads/{squad-slug}/squad.manifest.json
 Output: output/{squad-slug}/
-Logs: aios-logs/{squad-slug}/
+Logs: aioson-logs/{squad-slug}/
 Media: media/{squad-slug}/
 LatestSession: output/{squad-slug}/latest.html
 Genomes:
-- [genoma aplicado ao squad]
+- [genome aplicado ao squad]
 
 AgentGenomes:
-- {role-slug}: [genoma-a], [genoma-b]
+- {role-slug}: [genome-a], [genome-b]
 
 Skills:
 - [skill-slug] — [descrição]
@@ -649,26 +975,89 @@ Subagents:
 - When: [pesquisa ampla], [comparação], [resumo], [paralelismo]
 ```
 
+### Passo 6 — Gerar plano de execucao (recomendado)
+
+Apos salvar metadados, avalie se o squad se beneficiaria de um plano de execucao.
+
+**Sempre gerar para:**
+- Squads com 4+ executores
+- Squads com workflows definidos
+- Squads criados a partir de investigacao (@orache)
+- Squads com mode: software ou mixed
+
+**Oferecer (mas nao forcar) para:**
+- Squads com 3 executores e objetivos moderadamente complexos
+- Squads de conteudo com pipelines multi-etapa
+
+**Pular para:**
+- Squads efemeros
+- Squads com 2 executores e fluxo linear obvio
+- Usuario recusou explicitamente (`--no-plan`)
+
+Ao gerar: leia e execute `.aioson/tasks/squad-execution-plan.md`.
+A tarefa produzira `.aioson/squads/{slug}/docs/execution-plan.md`.
+
+Apos o plano ser aprovado (ou pulado), prossiga com o round de aquecimento.
+
+Se o squad se qualifica mas o usuario quer pular:
+> "Pulando plano de execucao. Voce pode gerar um depois com `@squad plan {slug}`."
+
 ## Apos a geracao — confirme e rode o aquecimento (obrigatorio)
 
-Informe ao usuário quais agentes foram criados:
+Informe ao usuário quais executores foram criados, depois mostre a verificação de classificação e o score de cobertura:
 
 ```
 Squad **{squad-name}** pronto.
 
-Agentes criados em `.aioson/squads/{squad-slug}/agents/`:
-- @{role1} — [descrição em uma linha]
-- @{role2} — [descrição em uma linha]
-- @{role3} — [descrição em uma linha]
-- @orquestrador — coordena o time
+Executores criados em `.aioson/squads/{squad-slug}/`:
+- @{role1} (agent) — [descrição em uma linha]
+- @{role2} (agent) — [descrição em uma linha]
+- {worker-slug} (worker) — [script, sem LLM]
+- @orquestrador (agent) — coordena o time
 
 Você pode invocar qualquer agente diretamente (ex: `@roteirista`) para trabalho focado,
 ou trabalhar via @orquestrador para sessões coordenadas.
 
 CLAUDE.md e AGENTS.md atualizados com atalhos.
-Manifestos da squad criados em `.aioson/squads/{squad-slug}/agents/agents.md` e `.aioson/squads/{squad-slug}/squad.manifest.json`.
 ```
 
+**Verificação de classificação de executores (obrigatória antes do aquecimento):**
+
+Após confirmar a criação, valide a classificação:
+
+```
+Verificação de classificação:
+- {executor-slug} → type: {type} ✓ (motivo: {justificativa em uma linha})
+- {executor-slug} → type: {type} ✓ (motivo: ...)
+- {executor-slug} → type: {type} ✓ (motivo: ...)
+
+Todos os executores classificados. Nenhum executor sem tipo.
+```
+
+Se algum executor não tiver `type`, sinalize:
+```
+⚠ {executor-slug} sem tipo. Recomendado: {type} — motivo: {razão}.
+```
+
+**Score de cobertura (mostrar após a verificação de classificação):**
+
+```
+Score de cobertura do squad: {N}/5
+
+✓ Executores tipados        ({n} de {total} com tipo explícito)
+✓ Workflow definido         (1 workflow, {n} fases)
+✓ Checklists presentes      (quality.md)
+○ Tasks definidas           (nenhuma — adicione tasks/ para procedimentos recorrentes)
+○ Workers presentes         (nenhum script determinístico — avalie se alguma etapa é automável)
+
+Cobertura: {score}% — {Excelente | Boa | Mínima}
+```
+
+Limiares de score:
+- 5/5 → Excelente
+- 3-4/5 → Boa
+- 1-2/5 → Mínima — sugira o que adicionar em seguida
+
 Depois execute imediatamente o aquecimento — mostre como cada especialista abordaria o objetivo declarado AGORA com substância mínima:
 - leitura do problema
 - recomendação inicial
@@ -743,19 +1132,69 @@ Após salvar o arquivo:
 
 ## Restricoes
 
-- NÃO invente fatos do domínio — fique dentro do conhecimento do LLM ou do conteúdo do genoma.
+- NÃO invente fatos do domínio — fique dentro do conhecimento do LLM ou do conteúdo do genome.
 - NÃO pule o aquecimento — é obrigatório após a geração.
-- NÃO salve em memória a menos que o usuário peça explicitamente.
-- NÃO ofereça `Modo Genoma` como etapa inicial do `@squad`.
-- Quando o usuário quiser genomas, encaminhe para `@genoma` como fluxo separado.
+- NÃO salve na memória automática (sistema de memória do Claude) a menos que o usuário peça explicitamente.
+- SALVE os aprendizados do squad no diretório `learnings/` do squad — esta é persistência com escopo de squad, não memória do Claude.
+- Apresente os aprendizados ao usuário ao final da sessão antes de salvar.
+- NÃO ofereça `Modo Genome` como etapa inicial do `@squad`.
+- Quando o usuário quiser genomes, encaminhe para `@genome` como fluxo separado.
 - Agentes vão em `.aioson/squads/{squad-slug}/agents/`, HTML em `output/{squad-slug}/` — NÃO dentro de `.aioson/`.
-- Logs brutos vão apenas em `aios-logs/{squad-slug}/` na raiz do projeto — nunca dentro de `.aioson/`.
+- Logs brutos vão apenas em `aioson-logs/{squad-slug}/` na raiz do projeto — nunca dentro de `.aioson/`.
 - Midia da squad vai apenas em `media/{squad-slug}/` na raiz do projeto.
 - `.aioson/context/` aceita somente arquivos `.md` — não escreva arquivos não-markdown lá.
 - NÃO pule o entregável HTML — gere `output/{squad-slug}/{session-id}.html` após cada rodada de resposta.
 - NÃO crie uma squad sem `agents.md` e sem `squad.manifest.json`.
 - NÃO trate skills, MCPs e subagentes como implícitos — declare-os explicitamente na squad.
 
+## Consciencia do plano de execucao
+
+Antes da primeira sessao e no inicio de cada nova sessao:
+1. Verifique se `docs/execution-plan.md` existe no pacote do squad
+2. Se sim e status = `approved` → siga a sequencia de rounds do plano
+   - Leia os briefings do executor a partir do plano
+   - Siga as notas de orquestracao
+   - Apos cada round, verifique contra os quality gates do plano
+   - Se o plano define ordem de rounds, respeite-a a menos que o usuario sobrescreva explicitamente
+3. Se sim e status = `draft` → pergunte: "Existe um plano de execucao em rascunho. Aprovar antes de comecar?"
+4. Se nao → prossiga com orquestracao ad-hoc baseada no manifesto e guia de roteamento
+5. Apos cada sessao produtiva, verifique criterios de sucesso do plano
+6. Se o plano ficar obsoleto (manifesto do squad mudou apos criacao do plano), avise no inicio da sessao
+
+## Aprendizados do squad
+
+O squad acumula inteligência entre sessões. Isso torna cada sessão melhor que a anterior.
+
+### No início da sessão
+1. Leia `learnings/index.md` no pacote do squad
+2. Carregue todas as preferências e insights de domínio no contexto ativo
+3. Carregue sinais de qualidade relevantes para o tópico desta sessão
+4. Carregue padrões de processo se estiver planejando orquestração com múltiplos rounds
+5. Mencione brevemente os aprendizados carregados: "Carregados N aprendizados de M sessões anteriores."
+
+### Durante a sessão
+Ao detectar um sinal de aprendizado (correção do usuário, rejeição, nova informação, problema de qualidade):
+- Registre internamente
+- NÃO interrompa a sessão para discutir
+
+### Ao final da sessão
+1. Liste os aprendizados detectados (máx. 3-5)
+2. Apresente ao usuário de forma não intrusiva
+3. Salve os aprendizados aprovados no diretório `learnings/`
+4. Atualize `learnings/index.md`
+
+### Verificações de promoção
+Após salvar novos aprendizados:
+- Verifique se algum aprendizado de qualidade tem frequência ≥ 3 → ofereça promoção para regra
+- Verifique se os aprendizados de domínio para este domínio somam ≥ 7 → ofereça criação de skill de domínio
+- Verifique se alguma preferência está estável por ≥ 5 sessões → marque como estabelecida
+
+### NUNCA faça
+- Salvar aprendizados sem ao menos mostrá-los ao usuário
+- Interromper uma sessão produtiva para discutir captura de aprendizados
+- Manter mais de 20 aprendizados ativos por squad (consolide ou arquive)
+- Tratar aprendizados obsoletos (90+ dias) como verdade atual
+
 ## Contrato de output
 
 - Arquivos dos agentes: `.aioson/squads/{squad-slug}/agents/` (editáveis pelo usuário, invocáveis via `@`)
@@ -765,8 +1204,8 @@ Após salvar o arquivo:
 - HTMLs de sessão: `output/{squad-slug}/{session-id}.html`
 - Latest HTML: `output/{squad-slug}/latest.html`
 - Drafts `.md`: `output/{squad-slug}/`
-- Genomas vinculados: `.aioson/squads/{slug}/squad.md`
-- Logs: `aios-logs/{squad-slug}/`
+- Genomes vinculados: `.aioson/squads/{slug}/squad.md`
+- Logs: `aioson-logs/{squad-slug}/`
 - Midia: `media/{squad-slug}/`
 - CLAUDE.md: atualizado com atalhos `/agente`
 - AGENTS.md: atualizado com atalhos `@agente`