atlas-workflow 0.8.2 → 0.9.0

package/hosts/opencode/.opencode/skills/atlas-workflow-orchestrator/SKILL.md

@@ -8,7 +8,7 @@ category: Development Automation
 
 Orquestra pipelines de desenvolvimento de features no projeto Atlas, automatizando a sequência de skills sob demanda com um único comando.
 
-> **v0.3 — MCP como fonte obrigatória de status.** Cada gate materializado deve ser consultado via MCP antes de avançar: `atlas_ping`, `atlas_preflight`, `atlas_verify_artifact`, `atlas_scan_prd`, `atlas_verify_template_conformance`, `atlas_lock_dispatch` e `atlas_assert_after_plan`. Sem resposta MCP, sem resultado exigido ou status bloqueante → workflow abortado, sem fallback narrativo. Edge cases de ambiente (conflito plugin/nativo, MCP indisponível, estado corrompido, lock conflict e drift de versão) bloqueiam com causa, impacto e próxima ação segura.
+> **MCP é fonte obrigatória de status.** Cada gate é consultado via MCP antes de avançar (tools por fase na Fase 0 e nos fluxos). Sem resposta MCP, sem resultado exigido ou status bloqueante → workflow abortado, sem fallback narrativo. Edge cases de ambiente (conflito plugin/nativo, MCP indisponível, estado corrompido, lock conflict, drift de versão) bloqueiam com causa, impacto e próxima ação segura.
 
 ## Sintaxe
 
@@ -124,33 +124,24 @@ A única interação legítima com o usuário é **dentro de uma fase** — o `A
 
 ## Papel do orquestrador (fronteira de determinismo pela mutação de código)
 
-O orquestrador **coordena a execução**, não implementa código. Pense nele como um maestro: aponta para cada músico (sub-agent) na ordem certa e espera cada um terminar. **Ele nunca pega o instrumento de código.**
+O orquestrador **coordena a execução**, não implementa código — maestro que aponta cada sub-agent na ordem e espera terminar, **nunca pega o instrumento de código**. A fronteira de determinismo é a **mutação de código** (PRD D10), com **duas fases**:
 
-A fronteira de determinismo é a **mutação de código** (PRD D10), e ela tem **duas fases** com regras diferentes:
+- **ANTES do plano validado — autoria documental livre no fio principal.** Pode autorar PRD, entrevistar e escrever `PLAN_*.md` direto; fases documentais não exigem sub-agent (documento não muta o produto). **Ao finalizar um PRD inline, estampar `| Status | Aprovado para implementação |`** — é o `required_status` do gate TC; sem isso o PRD sai `Draft` e trava o TC em rodadas de correção.
+- **DEPOIS do plano validado (`atlas_verify_artifact` + TC `passed`) — mãos atadas fortes.** Não edita mais PRD/plano/código nem roda comando mutante; só coordena (despachar sub-agent, ler artefato pra verificar gate, ecoar banner, montar output).
 
-- **ANTES do plano validado — autoria documental é livre no agente principal.** O orquestrador (agente principal) **pode** autorar o PRD, conduzir a entrevista e **escrever o `PLAN_*.md` diretamente**. Fases puramente documentais (gerar/maturar PRD, entrevistar, redigir plano) **não exigem** despacho de sub-agent. Documento não é código: autoria não muta o produto. **Ao autorar/finalizar um PRD no fio principal, estampar `| Status | Aprovado para implementação |`** — é o `required_status` que o gate TC exige (ver Validate PRD). Sem isso o PRD sai `Draft` e trava o TC em 2-3 rodadas de correção. (O `atlas-sprint-prd-generator` já faz isso; a autoria inline deve seguir igual.)
-- **DEPOIS do plano validado (`atlas_verify_artifact` + TC `passed`) — mãos atadas fortes.** A partir daí o orquestrador **NÃO** edita PRD/plano, **NÃO** edita código, **NÃO** roda comando mutante. Só **coordena a execução**: despachar sub-agent, ler artefato para verificar gate, ecoar banner, montar o output final.
-- **Execução de código é SEMPRE gateada — nunca afrouxa.** Toda mutação de código vive obrigatoriamente em sub-agent `plan_execute` (blocking, um por vez) + validador frio `task_validator` (PRD D10). O orquestrador **nunca escreve código**, em nenhuma fase, em nenhum modo. Isto não muda com a autoria documental livre acima.
-
-- **Permitido:** parse de args; classificar input; autorar PRD/entrevista/`PLAN_*.md` **enquanto o plano não foi validado**; despachar sub-agent (blocking, um por vez); ler artefato em disco para verificar gate; ecoar banner; montar o output final.
-- **Proibido (Gate G9):** escrever/editar **código**; rodar comando mutante (`flutter`, `test`, `git add/commit`); editar PRD/plano **depois** do plano validado; implementar "em paralelo"; usar `run_in_background` para fases do pipeline.
-- **Dispatch blocking:** despacha → **espera o retorno** → verifica gate → próxima fase. Nunca dois sub-agents simultâneos. Nunca trabalhar enquanto um sub-agent roda.
+Execução de código é **sempre** sub-agent `plan_execute` (blocking, um por vez) + validador frio `task_validator` (Gate G9/G7 — detalhe na tabela de gates). Dispatch blocking: despacha → espera retorno → verifica gate → próxima fase. Nunca dois sub-agents simultâneos.
 
 ### Verbo de dispatch é host-agnóstico (não assuma "Agent tool")
 
-O **mecanismo** de despacho de sub-agent **varia por host** — leia `subagent_dispatch.mechanism`, `.example` e `validator_dispatch` de `atlas_capabilities` e use o **verbo nativo do host**. Não hardcode o verbo do Claude. Mapeamento (ilustrativo; a fonte de verdade em runtime é `atlas_capabilities`):
+O **mecanismo** varia por host — leia `subagent_dispatch.mechanism`, `.example` e `validator_dispatch` de `atlas_capabilities` (fonte de verdade em runtime) e use o **verbo nativo**. Não hardcode o verbo do Claude. Mapeamento ilustrativo, onde `<exec>` é o id da fase (`plan-execute`/`direct-execute`/`slice-review`/`task-validator`):
 
 - **claude:** `Agent(subagent_type: "atlas-<exec>", prompt: ...)`
-- **codex:** `spawn_agent(agent_type: "atlas-<exec>", items: [{ type: "text", text: "<state_path ou task>" }])` usando custom agent nativo instalado em `CODEX_HOME/agents/atlas-<exec>.toml` pelo `init codex` (`.codex/agents/` no bundle é fonte gerada). Como em todo host, a topologia é **sibling**: o executor retorna `validator_handoff_required` com `state_path`, e o orquestrador despacha **explicitamente** `spawn_agent(agent_type: "atlas-task-validator", items: [{ type: "text", text: "<state_path>" }])` como sub-agent irmão isolado. O registro Codex do validator é gerado com `model = "gpt-5.4"` e `model_reasoning_effort = "high"`. Se `agent_type: "atlas-task-validator"` não existir no host, bloquear a slice (fail-closed); é proibido fallback para `default`, `$atlas-task-validator` ou validação inline.
+- **codex:** `spawn_agent(agent_type: "atlas-<exec>", items: [{ type: "text", text: "<state_path ou task>" }])` (custom agent nativo em `CODEX_HOME/agents/atlas-<exec>.toml`; `.codex/agents/` do bundle é gerado). `$atlas-*` sozinho **não** isola contexto — use `spawn_agent`.
 - **opencode:** `@atlas-<exec>` (ou auto por description)
 - **pi:** `subagent({ agent: "atlas-<exec>", task, context: "fresh" })`
 - **generic:** subagente nativo do host
 
-Onde `<exec>` é o id resolvido da fase (`plan-execute`, `direct-execute`, `slice-review`, `task-validator`).
-
-> **Rodar a mutação de código no fio principal é violação do Gate G9 — em QUALQUER host.** Ausência da "Agent tool" (porque o host não é Claude) **não** é licença para executar inline: é sinal de que você deve usar o **verbo de dispatch daquele host**. No Codex, `$atlas-*` sozinho não isola contexto; use `spawn_agent`. Se o host não expõe nenhum mecanismo de sub-agent (preflight `subagent_available:false`), o gate PREREQ já abortou em `ready` — você nunca chega aqui sem isolamento.
-
-Se você (orquestrador) está prestes a editar **código**, **pare**: esse trabalho é do sub-agent de execução. Despache-o (verbo nativo do host) e espere. (Autoria de PRD/plano antes da validação é a única autoria permitida no fio principal.)
+> Ausência de "Agent tool" (host ≠ Claude) **não** é licença pra executar inline — é sinal pra usar o verbo daquele host (Gate G9, qualquer host). Host sem mecanismo de sub-agent já abortou em PREREQ; você nunca chega aqui sem isolamento.
 
 ## Protocolo de banner (única comunicação de progresso)
 
@@ -177,6 +168,7 @@ Regras inegociáveis. Violação = parar, não contornar.
 | TC | **Conformidade de template via MCP.** PRD e PLAN só avançam como artefatos documentais se `atlas_verify_template_conformance` retornar `passed` e `pending_count: 0`. Pendência bloqueia com `next_action`. | PRD + plano |
 | G6 | **Status verificado, não auto-reportado.** O ✅ de cada item no output só pode ser marcado após confirmar o artefato em disco. Faltou artefato exigido pelo modo → status final `incomplete`, nunca `completed`. | output |
 | G7 | **Execução de código roda SEMPRE como sub-agent despachado (verbo nativo do host, lido de `atlas_capabilities`), nunca no contexto do orquestrador.** A **autoria** do `PLAN_*.md` pode ser feita pelo orquestrador no fio principal **enquanto o plano não foi validado** (autoria documental, PRD D10) — mas o plano só vira confiável após `atlas_verify_artifact` + TC `passed`. A **execução do plano** (`plan_execute`) e qualquer mutação de código vão obrigatoriamente a sub-agent. Antes de iniciar/concluir fase de execução, usar `atlas_lock_dispatch`; fase fora de ordem ou paralela bloqueia. Depois do plano validado, o orquestrador não edita mais o plano (mãos atadas fortes). | plano + execução |
+| G12 | **Executor vivo precisa provar progresso.** Ao iniciar `plan_execute`, `atlas_lock_dispatch(start)` cria liveness de bootstrap/progresso. O executor precisa emitir `atlas_lock_dispatch(checkpoint, phase=plan_execute, event=...)` cedo, começando por `executor_started`/`skill_loaded`, depois `plan_loaded`, `handoff_accepted`, `task_started`, `first_write` e `state_path_created` conforme avança. `state_path_created` exige `state_path` legível/parseável, e `atlas_lock_validator(start)` só abre validator se o último checkpoint for `state_path_created` para exatamente o mesmo `state_path`. Se o sub-agent não retornar, travar, ficar sem primeiro checkpoint, ou ficar com checkpoint antigo sem avanço, o orquestrador chama `atlas_lock_dispatch(action=status, phase=plan_execute)`: `executor_bootstrap_timeout`/`executor_progress_timeout` viram `stalled`, o lock é liberado para `retry_plan_execute`, e a execução não pode ser declarada completa. Sem checkpoint/progresso não há "em andamento" confiável. | execução |
 | G8 | **Ordem fixa de validação: `task-validator` ANTES, `slice-review` POR ÚLTIMO. Nunca em paralelo.** Conclusão de `plan_execute` usa `atlas_lock_dispatch` com `validator_status: passed`; review só inicia após execução concluída. | validação + review |
 | PREREQ | **Pré-requisitos de determinismo (hard-fail, DEC-004).** `atlas_preflight` verifica, **antes de tudo**, se o host tem subagente + MCP (essenciais). Ausente (ex.: pi sem `pi-mcp-adapter`/`pi-subagents`, host MCP-only sem subagente) → aborta em `ready` com `missing_prerequisites`/`next_action`. Sem degradação, sem validator inline, qualquer tamanho. `todo` não-essencial segue sem mirror. | roteamento |
 | DEP | **Dependência de backlog não satisfeita = hard-fail determinístico.** Se o input é `backlog-item` e o item declara `Dependências` (ex.: S40 dep S39) cujo status, lido no mesmo backlog/registro de onde o item veio, **não** é `done`, abortar em `ready` com `unmet_dependencies`, causa e `next_action` (executar a dependência primeiro). Sem improviso e sem pergunta: ou a dep está `done` e segue, ou bloqueia com causa. Não confundir com decisão em aberto (que não bloqueia). | roteamento (backlog-item) |
@@ -188,6 +180,10 @@ Regras inegociáveis. Violação = parar, não contornar.
 
 ## Fluxo de execução
 
+### [EXEC] — passo comum de execução + validação (idêntico em `full`/`direct`/`execute`)
+
+`atlas_lock_dispatch(action=start, phase=plan_execute)`; despachar `plan_execute` como sub-agent blocking (lê `PLAN_*.md` em `full`/`execute`, PRD em `direct`). O executor emite checkpoints G12; sem retorno/progresso, chamar `atlas_lock_dispatch(action=status, phase=plan_execute)` e tratar `executor_bootstrap_timeout`/`executor_progress_timeout` como `stalled`/retry — nunca como execução em andamento. O executor retorna `validator_handoff_required` com `state_path`; o MCP só abre o slot após o checkpoint `state_path_created` para esse mesmo `state_path`. Validação sempre **sibling**: `atlas_lock_validator(action=start)`, despachar **um** `task_validator`, exigir no output o `dispatch_token` do slot e fechar com `validator_run_id` + `dispatch_token`. Em `fail`: `repair_start`, despachar `atlas-findings-repair` com `{state_path, findings, validator_attempt, repair_run_id, repair_budget: 1}`, exigir atualização do mesmo `state_path`, fechar com `repair_run_id` e rodar o **2º e último** validator. `passed`/`passed_with_observations` são terminais aprovados; status diferente bloqueia review e output completed.
+
 ### Full mode
 
 Artefatos esperados (em ordem): `PRD_*.md` → (`PRD_*.md` atualizado) → `PLAN_*.md` → diff de código → relatório do validador.
@@ -199,7 +195,7 @@ Artefatos esperados (em ordem): `PRD_*.md` → (`PRD_*.md` atualizado) → `PLAN
 5. **Plan** — `atlas_lock_dispatch(action=start, phase=plan_handoff)`, carregar/invocar `plan_handoff` no fio principal para redigir `PLAN_*.md`, depois chamar `atlas_verify_artifact` e `atlas_verify_template_conformance(artifact_type=plan)`. Concluir a fase com `atlas_lock_dispatch(action=complete, phase=plan_handoff)`. **Nenhuma linha de código pode ter sido escrita até aqui.**
    - **G11:** se `PLAN_*.md` foi validado, chamar `atlas_assert_after_plan`. Se a próxima ação não for `dispatch_plan_execute_blocking`, abortar.
 6. **Validate plan** — se há gaps → dispara entrevista, propaga e continua (ver "Decisão em aberto ≠ parada"). Não para pra pedir permissão.
-7. **Execute** — `atlas_lock_dispatch(action=start, phase=plan_execute)`, despachar `plan_execute` como sub-agent lendo o `PLAN_*.md`. O executor retorna `validator_handoff_required` com `state_path`; o orquestrador abre um slot via `atlas_lock_validator(action=start)`, despacha **um** `task_validator`, exige no output o `dispatch_token` do slot e fecha com `validator_run_id` + `dispatch_token`. Se o veredito for `fail`, chama `repair_start`, despacha `atlas-findings-repair` com `{state_path, findings, validator_attempt, repair_run_id, repair_budget: 1}`, exige atualização do mesmo `state_path`, fecha com `repair_run_id` e só então roda o **2º e último** validator. Ao obter `passed` ou `passed_with_observations`, conclui `plan_execute` com o terminal. Status diferente bloqueia review e output completed.
+7. **Execute** — rodar o passo **[EXEC]** (lê `PLAN_*.md`).
 8. **Review (condicional)** — somente após execução concluída e se `--review` → `atlas_lock_dispatch(action=start, phase=slice_review)`, despachar `slice_review`, depois `atlas_lock_dispatch(action=complete, phase=slice_review)`.
 9. **Output** — ledger verificado com fonte MCP por gate/fase (ver "Output") + próximos passos.
 
@@ -209,7 +205,7 @@ Artefatos esperados: `PRD_*.md` → (atualizado) → diff de código → relató
 
 1. Parse / Generate PRD (se necessário) + `atlas_verify_artifact`.
 2. Validate PRD → `atlas_scan_prd` + `atlas_verify_template_conformance`; entrevista condicional reexecuta os gates.
-3. **Execute** — `atlas_lock_dispatch(action=start, phase=plan_execute)`; despachar `plan_execute` como sub-agent blocking a partir do PRD. O executor retorna `validator_handoff_required` com `state_path`; o orquestrador abre o slot, despacha o validator e fecha usando `validator_run_id` + `dispatch_token`. Em `fail`, abre repair, passa `{state_path, findings, validator_attempt, repair_run_id, repair_budget: 1}` ao `atlas-findings-repair`, mantém o mesmo `state_path`, fecha o repair e roda o **2º e último** validator. `passed` e `passed_with_observations` são terminais aprovados.
+3. **Execute** — rodar o passo **[EXEC]** (executor lê o PRD; sem `PLAN_*.md`).
 4. Review (condicional) — só após executor retornar 100% e dispatch MCP permitir.
 5. Output (ledger verificado).
 
@@ -221,7 +217,7 @@ Entrada: um **`PLAN_*.md` pronto**. Artefatos esperados: (plano já existe) →
 
 1. **Parse / classify** — `atlas_ping` → `atlas_capabilities` → **`atlas_classify_input`** no input (PRD D3/D6: o tipo é fato e precisa ser conhecido antes de travar o modo) → **`atlas_preflight(<modo efetivo>)`** (PREREQ hard-fail intacto). A classificação determina o tipo: se for plano, o modo efetivo é `execute` e o preflight trava `execute`; se o input não for plano, auto-rotear (ver Fase 0, passo 2b) e o preflight trava o modo roteado. **`classify_input` sempre precede `preflight`** (o preflight trava o modo efetivo, não o pedido).
 2. **Reverificar o plano na entrada** — `atlas_verify_artifact` no `PLAN_*.md` (G1) + `atlas_verify_template_conformance(artifact_type=plan)` (TC). Plano velho/manual/inválido **trava aqui** com `next_action` em linguagem de produto (PRD D11 — "autoria é livre, execução é gateada"). Sem reverificação válida não há dispatch.
-3. **Executar** — `atlas_lock_dispatch(action=start, phase=plan_execute)`; despachar `plan_execute` como sub-agent blocking lendo o `PLAN_*.md`. A validação é sempre **sibling**: o executor escreve `state_path` e para; o orquestrador despacha o validator via `atlas_lock_validator` e fecha o slot somente com `validator_run_id` + `dispatch_token`. Ao obter `passed` ou `passed_with_observations`, concluir `plan_execute` com o terminal correspondente. `plan_execute` é aceito como **primeira fase** em `execute` (sem fase nova; PRD D13).
+3. **Executar** — rodar o passo **[EXEC]** (lê `PLAN_*.md`). `plan_execute` é aceito como **primeira fase** em `execute` (sem fase nova; PRD D13).
 4. **Review (condicional)** — só após execução concluída e se `--review` → `atlas_lock_dispatch(action=start, phase=slice_review)`, despachar `slice_review`, depois `complete`.
 5. **Output** — ledger verificado; `guarantee_level` = `full_pipeline` (PRD D12).
 
@@ -238,15 +234,7 @@ Entrada: um **`PLAN_*.md` pronto**. Artefatos esperados: (plano já existe) →
 
 ## Validação automática de PRD
 
-O scan é **determinístico**. Marca ambiguidade quando uma seção contém qualquer padrão abaixo (lista canônica embutida no MCP):
-
-- **§1 Contexto e objetivo:** `TBD`, `a confirmar`, `talvez`, `não definido`
-- **§2 Escopo:** `pode ser`, `depende de`, `ainda não`, `incompleto`
-- **§3 Decisões:** vazio/conteúdo mínimo, `vago`
-- **§4 Fluxos e cenários UX:** `a definir`, `gap`, `depende de`
-- **§5 Contrato funcional e invariantes:** `ainda não definido`, `mock apenas`, `a confirmar`
-
-Antes de contar bloqueantes, aplicar exclusões estreitas do config (`exclude_if_line_contains`, hoje `depende de plano`) para frases de sucesso/resultado que descrevem dependência operacional já planejada. Não usar julgamento livre: a exclusão precisa estar no config e ser logada.
+O scan é **determinístico** e roda **dentro do MCP** (`atlas_scan_prd`): a lista canônica de padrões §1-§5 e as exclusões de config (`exclude_if_line_contains`) são embutidas e mantidas no servidor — o orquestrador **não** reaplica padrões por conta própria, só consome o resultado. Não usar julgamento livre.
 
 **Threshold = 1.** Se ≥ 1 padrão bloqueante → o orquestrador invoca `atlas-prd-interview` no fio principal. **Gate G5:** se 0 padrões bloqueantes, registrar `Ambiguity scan: 0 padrões bloqueantes — entrevista pulada` no output. Não há decisão subjetiva de "tenho certeza, pulo".
 
@@ -254,16 +242,16 @@ Antes de contar bloqueantes, aplicar exclusões estreitas do config (`exclude_if
 
 ## Decisão em aberto ≠ parada
 
-Decisão pendente **não bloqueia o pipeline** e **não vira menu de permissão**. Vale para **qualquer fonte** onde a decisão apareça — scan de PRD, entrevista, validação de plano, `PERGUNTAS_EM_ABERTO.md`, doc de discussão/decisões (ex.: `DISCUSSAO_*.md`) ou o próprio backlog. A fonte não muda o tratamento.
+Detalhe do caminho que a "Princípio de continuação automática" exige para decisão pendente de **qualquer fonte** (scan/entrevista/validação de plano/`PERGUNTAS_EM_ABERTO.md`/`DISCUSSAO_*.md`/backlog — a fonte não muda o tratamento):
 
-Caminho determinístico:
+1. **Garantir o PRD primeiro.** Em `full`/`direct`, se o PRD não existe, **gerar o PRD draft** com as decisões marcadas. A entrevista é **PRD-scoped**: roda **sobre** o PRD, nunca antes. Detectar decisão não antecipa nem pula a geração do PRD.
+2. **Disparar `atlas-prd-interview`** sobre o PRD — resolve via `AskUserQuestion` (interação dentro da fase, não pedido de permissão).
+3. **Propagar** ao PRD/plano/DEC/registro de origem.
+4. **Reexecutar** os gates afetados (`atlas_verify_artifact`/`atlas_scan_prd`/TC) e **continuar** automaticamente.
 
-1. **Garantir o PRD primeiro.** Em `full`/`direct`, se o PRD ainda não existe, **gerar o PRD draft** (passo "Generate PRD", automático — ver "Princípio de continuação automática") com as decisões marcadas. A entrevista é **PRD-scoped**: roda **sobre** o PRD, nunca antes dele. Detectar decisão **não** antecipa nem pula a geração do PRD — primeiro materializa o PRD, depois resolve nele.
-2. **Disparar `atlas-prd-interview`** sobre o PRD — resolve a decisão via `AskUserQuestion` (interação **dentro da fase**, não pedido de permissão pra avançar).
-3. **Propagar** a resolução ao PRD/plano/DEC/registro de origem.
-4. **Reexecutar** os gates afetados (`atlas_verify_artifact`/`atlas_scan_prd`/TC) e **continuar** (plano→execução) automaticamente.
+Marcar TBD e adiar só se o usuário pedir **explicitamente** — nunca por iniciativa do orquestrador.
 
-O default é **gerar PRD, resolver via entrevista e seguir**. Não existe ponto de parada "A) resolver / B) seguir com TBD / C) adiar" como rotina do pipeline, nem "responda só: seguir com recomendação ou D=...". Marcar TBD e adiar só se o usuário pedir **explicitamente** no fio — nunca por iniciativa do orquestrador. A única parada é gate duro `blocked` (ver "Princípio de continuação automática").
+> `PERGUNTAS_EM_ABERTO.md` é verificado na validação de PRD; Q- aberta da sprint **não é blockage** — entra neste mesmo caminho.
 
 ---
 
@@ -324,12 +312,6 @@ Se `full` gerou `PLAN_*.md` mas não despachou `plan_execute`, o cabeçalho deve
 
 ---
 
-## Integração com PERGUNTAS_EM_ABERTO.md
-
-Plugin verifica `PERGUNTAS_EM_ABERTO.md` durante validação de PRD. Q-… abertas relacionadas à sprint **não param o pipeline** (Q- aberta não é blockage). O orquestrador trata como decisão em aberto: dispara `atlas-prd-interview` para resolver, propaga a decisão (PRD/plano/DEC/registro) e **continua** o pipeline. Ver "Decisão em aberto ≠ parada".
-
----
-
 ## Error handling
 
 - **Pré-flight falha (skill ausente no host)** → para, reporta, não emula (ver Fase 0).
@@ -399,14 +381,4 @@ orquestrador
 
 Regra de ouro: **um sub-agent por fase de execução, em série, blocking, sustentado por MCP**. O orquestrador espera cada sub-agent terminar antes do próximo e **nunca** trabalha em paralelo nem escreve código (Gate G9). Autoria documental (PRD/plano) é livre no fio principal **antes** do plano validado; depois, mãos atadas. Em `full`, `PLAN_*.md` validado obriga `plan_execute` no mesmo workflow (G11). `task-validator` ⟂ `slice-review` jamais coexistem. Progresso só por banner (string do MCP).
 
-> Histórico completo (todas as versões, com detalhe de cada correção) vive em [`CHANGELOG.md`](../../../../CHANGELOG.md) na raiz do repo — fonte canônica. Abaixo só as entradas recentes relevantes ao contrato do orquestrador.
-
-- **v0.8.1** — Patch de confiabilidade de contrato (só SKILL/command; sem código MCP, sem schema, schema v5 intacto). Fecha o vazamento de **parada discricionária**: nova seção "Princípio de continuação automática" (pipeline fire-and-continue — só para em gate duro `blocked` ou blockage de ambiente real) + "Decisão em aberto ≠ parada" (decisão pendente de **qualquer fonte** — scan/entrevista/`PERGUNTAS_EM_ABERTO.md`/`DISCUSSAO_*.md`/backlog — dispara entrevista, propaga e **continua**, nunca vira menu de permissão nem "responda só: seguir ou D=..."; sequência travada: em `full`/`direct` gera PRD draft **primeiro**, entrevista roda **sobre** o PRD). Proíbe modo fora do contrato ("Modo Discussão"/"dry-run") e "quer que eu gere/continue?"; PRD ausente em `full`/`direct` gera automático. Novo **Gate DEP**: dependência de backlog não-`done` é hard-fail determinístico (não confundir com decisão em aberto). Origem: relato de pausa indevida no pipeline (orquestrador parava pra pedir confirmação que o contrato não exige).
-- **v0.8.0** — Proof-of-work do validador frio (Gate G4, R20). `atlas_lock_validator(start)` emite um `challenge` (sha256 de um arquivo do boundary do `state_path`); o validador irmão lê via `validator_recovery.challenge`, computa o hash e devolve em `challenge_response`; o `complete` recomputa do disco e bloqueia (`challenge_failed`, slot preservado) em divergência/ausência. Atestação mecânica de que o veredito leu o boundary — fecha o atalho preguiçoso de afirmar `pass` sem ler código. **Não** é prova de isolamento não-forjável (MCP fala stdio com um único caller); best-effort (boundary sem arquivo legível → sem challenge, sem enforcement). Schema `atlas_capabilities` intacto (v5).
-- **v0.7.2** — Patch de confiabilidade (sem breaking, schema v5 intacto). `ping().capabilities` passa a ser **derivado de `toolsList()`** (fonte única) — fim do drift que omitia `atlas_classify_input`, capaz de travar run válida na Fase 0; guard cruzado novo. CI ganha job `cross-os` (Windows/macOS, Node puro). Doc: proveniência do `dispatch_token` no `atlas-task-validator` e `.gitattributes` marcando artefatos gerados.
-- **v0.7.1** — Patch de confiabilidade. MCP: `atlas_run_state(upsert)` faz merge top-level (não derruba `dispatch.active`); `findActiveRunConflict` só bloqueia conflito de lock real; `atlas_verify_artifact` aceita `artifact_kind`. Gate G4 endurecido: falha de dispatch em runtime = `blocked`, nunca inline (R17); `dispatch_token` do `complete` vem do output do próprio validador irmão (R19).
-
-## Próximas fases
-
-- **v0.4** hardening de empacotamento e smoke multi-host
-- **v1.0** contrato estável de workflow
+> Histórico de versões (detalhe de cada correção) e roadmap: [`CHANGELOG.md`](../../../../CHANGELOG.md) na raiz — fonte canônica.

package/hosts/pi/.pi/agents/atlas-direct-execute.md

@@ -43,6 +43,29 @@ Execute directly from a PRD/spec/task while preserving execution quality: explic
 
 This is not planless execution. Replace the visible markdown plan with a compact operational contract held in the current turn and passed to validation.
 
+## Executor liveness checkpoints
+
+Depois de carregar esta skill e antes de qualquer discovery longo, emita um checkpoint MCP:
+
+```json
+atlas_lock_dispatch({
+  "action": "checkpoint",
+  "phase": "plan_execute",
+  "event": "executor_started"
+})
+```
+
+Em seguida, emita checkpoints materiais conforme avança:
+
+- `skill_loaded` — skill carregada e contrato reconhecido.
+- `plan_loaded` — PRD/spec/task de entrada lido.
+- `handoff_accepted` — boundary, obligations, `state_path` alvo e contrato direto aceitos.
+- `task_started` — primeira task começou.
+- `first_write` — primeira mutação de workspace feita.
+- `state_path_created` — state file escrito antes de devolver `validator_handoff_required`.
+
+Se não conseguir emitir checkpoint por MCP, retorne `blocked`: liveness não é comprovável. Sem `state_path_created` com o mesmo `state_path`, `atlas_lock_validator(start)` bloqueia em G12 e o orquestrador não pode despachar o validador frio.
+
 ## Use Criteria
 
 Use when all are true:
@@ -72,6 +95,8 @@ Ask at most 1-3 blocking questions only when a reasonable assumption could chang
 
 ### 1. Load inputs
 
+First, emit `executor_started`, then `skill_loaded`, before doing any long scan.
+
 Read the user-provided PRD/spec/task and any directly referenced files needed to resolve scope. If the input names repo artifacts, verify those artifacts exist before editing.
 
 Extract only execution-relevant items:
@@ -89,6 +114,8 @@ Extract only execution-relevant items:
 
 If the PRD references another PRD or code contract as dependency, inspect enough to confirm the dependency shape and required bridge. Do not satisfy a dependency by creating parallel synthetic contracts unless the PRD explicitly allows it.
 
+After the input is loaded, emit `plan_loaded`. After validating the execution boundary, obligations, and `state_path` target, emit `handoff_accepted`.
+
 ### 2. Build Compact Execution Contract
 
 Before editing, write a compact contract in the working response or internal task state. Size follows complexity: terse for simple tasks, denser only where needed to preserve scope, invariants, and validator quality.
@@ -154,6 +181,8 @@ For each task, keep a tiny task contract:
 
 Do not widen scope for opportunistic cleanup.
 
+Before the first concrete task, emit `task_started`. After the first workspace mutation, emit `first_write`.
+
 ### 4. Gate each task
 
 Run focused checks appropriate to the diff:
@@ -180,6 +209,8 @@ For direct execution, the state file is still the only validator input. Use the
 
 The state file is the only validator input. Validation is always **sibling**, on every host: this executor **never** dispatches `atlas-task-validator` itself and never validates its own work in the same context. After tasks and local gates pass and the state file is written, this executor **stops mutation** and returns `validator_handoff_required` with the `state_path`. The orchestrator then dispatches `atlas-task-validator` as the next isolated sibling phase, locks it via `atlas_lock_validator`, and — if the verdict is `fail` — dispatches `atlas-findings-repair` (not this executor) before the **2nd and last** validator.
 
+After writing the state file and before returning, emit `state_path_created` with the same `state_path`.
+
 Do not paste the compact contract, diff, obligation ledger, local checks, or closure analysis packet into the state file's handoff. Those belong in the state file and referenced artifacts.
 
 **Finish all local work before the handoff — then stop idle.** Finish every local gate (lint, analyze, tests, `git diff --check`, diff-stat) and write the state file **before** returning the handoff. After returning `validator_handoff_required`, do nothing: no diff hygiene checks, no extra reads, no opportunistic edits, no parallel work. The orchestrator now owns the slice; any mutation here would change what the sibling validator reads and breaks determinism (same failure class as the orchestrator's G9).

package/hosts/pi/.pi/agents/atlas-plan-execute.md

@@ -56,6 +56,29 @@ Operate as a bounded state machine:
 
 Use `atlas_run_state` as the primary source of run state. Do not read or write run ledger files directly. If the MCP is unavailable, report the gate as unprovable and abort instead of continuing with a silent file fallback.
 
+## Executor liveness checkpoints
+
+Depois de carregar esta skill e antes de qualquer discovery longo, emita um checkpoint MCP:
+
+```json
+atlas_lock_dispatch({
+  "action": "checkpoint",
+  "phase": "plan_execute",
+  "event": "executor_started"
+})
+```
+
+Em seguida, emita checkpoints materiais conforme avança:
+
+- `skill_loaded` — skill carregada e contrato reconhecido.
+- `plan_loaded` — plano/PRD de entrada lido.
+- `handoff_accepted` — `plan_path`, `state_path` alvo, boundary e tasks aceitos.
+- `task_started` — primeira task começou.
+- `first_write` — primeira mutação de workspace feita.
+- `state_path_created` — state file escrito antes de devolver `validator_handoff_required`.
+
+Se não conseguir emitir checkpoint por MCP, retorne `blocked`: liveness não é comprovável. Não fique em discovery/preflight interno sem checkpoint. O orquestrador trata ausência de checkpoint como `stalled` via Gate G12.
+
 ## Plan path resolution
 
 Resolve plan paths in this order:
@@ -89,6 +112,8 @@ Esta skill aceita entrada pelo modo `execute` do orquestrador: um `PLAN_*.md` pr
 ## Required Workflow
 
 ### 1. Load the plan as an execution contract
+First, emit `executor_started`, then `skill_loaded`, before doing any long scan.
+
 Read the `atlas-plan-handoff` artifact. Extract at minimum:
 * **Execution metadata**: Prefix, mode, and validator options.
 * **Executive translation and PRD links** (from Section 1 — include path to PRD; cite `PRD §3` D* IDs, do not paste the full D* table).
@@ -106,12 +131,16 @@ If optional Section 9 (open questions / real blockers — **not** PRD §7 Apênd
 
 When Section 8 checklist is thin, read **PRD §4–6** from the PRD path in the plan header for business acceptance.
 
+After the plan is loaded, emit `plan_loaded`. After validating the execution boundary and `state_path` target, emit `handoff_accepted`.
+
 ### 2. Create a task-scoped execution contract
 Before editing code, write a short task contract for the current task only (objective, files, invariants, local checks, and repair budget).
 
 ### 3. Implement in the smallest coherent slice
 Do not implement the entire feature before validating anything. Prefer one task at a time. Follow closed decisions from the plan.
 
+Before the first concrete task, emit `task_started`. After the first workspace mutation, emit `first_write`.
+
 ### 4. Run a focused quality gate after each task slice
 Run only the checks that are relevant to the current diff and task risks (linter, analyze of the affected package, or tests).
 
@@ -147,6 +176,9 @@ Create `.atlas/state/<run_id>/<slice>.json` following `packages/templates/STATE_
 
 Validation is always **sibling**, on every host. The validator is registered as a real subagent on every host, but this executor **never** dispatches it and never validates its own work. After tasks and local gates pass and the state file is written, this executor **stops mutation** and returns `validator_handoff_required` with the `state_path`. The orchestrator dispatches `atlas-task-validator` as the next isolated sibling phase, locks it via `atlas_lock_validator`, and — if the verdict is `fail` — dispatches `atlas-findings-repair` (not this executor) before the **2nd and last** validator.
 
+After writing the state file and before returning, emit `state_path_created` with the same `state_path`.
+Without this exact checkpoint, `atlas_lock_validator(start)` blocks in G12 and the orchestrator cannot dispatch the cold validator.
+
 The only handoff input is `state_path`. Do not paste the contract, diff, or task list inline. The validator reads everything it needs from the state file and the plan it points to. (`atlas_capabilities` is the runtime source of truth for the dispatch mechanism the orchestrator uses — see `references/host-adapters.md`.)
 
 **Finish all local work before the handoff — then stop idle.** Finish every local gate (lint, analyze, tests, `git diff --check`, diff-stat) and write the state file **before** returning the handoff. After returning `validator_handoff_required`, the executor must not mutate anything: the orchestrator now owns the slice, and any mutation here would change what the sibling validator reads and breaks determinism (same failure class as the orchestrator's G9).

package/hosts/pi/atlas/VERSION

@@ -1 +1 @@
-0.8.2
+0.9.0

package/hosts/pi/atlas/orchestrator/README.md

@@ -220,9 +220,16 @@ Veja este README, `packages/mcp-server/README.md` e os SKILL.md `atlas-*` para o
 
 ---
 
-**Plugin version:** 0.8.2
+**Plugin version:** 0.9.0
 **Author:** Paulo Borini
-**Last updated:** 2026-06-15
+**Last updated:** 2026-06-16
+
+### Novidades v0.8.4 — liveness do executor (Gate G12)
+
+- `plan_execute` agora tem liveness explícito: `atlas_lock_dispatch(start)` cria deadline de bootstrap e o executor precisa emitir checkpoints materiais.
+- `atlas-plan-execute` deve reportar `executor_started`, `skill_loaded`, `plan_loaded`, `handoff_accepted`, `task_started`, `first_write` e `state_path_created` conforme avança.
+- Se o sub-agent não retornar/progredir, o orquestrador consulta `atlas_lock_dispatch(status)`; bootstrap vencido vira `executor_bootstrap_timeout`, checkpoint antigo sem avanço vira `executor_progress_timeout`; ambos persistem `stalled`, liberam retry e não podem ser tratados como execução em andamento.
+- `atlas_lock_validator(start)` só abre o validator depois de `state_path_created` para o mesmo `state_path`; checkpoint final sem arquivo legível é bloqueado.
 
 ### Novidades v0.8.2 — release/npm e procedimento de bump
 

package/hosts/pi/atlas/orchestrator/references/host-adapters.md

@@ -23,22 +23,23 @@ Os dois devem permanecer consistentes. O descritor em código vive em `packages/
 | env `CODEX_HOME` / `CODEX_PLUGIN_ROOT` | `codex` |
 | env `ATLAS_HOST=opencode` (injetado por `opencode.json`) | `opencode` |
 | env `ATLAS_HOST=pi` (injetado pela config do `pi-mcp-adapter`) | `pi` |
+| env `ATLAS_HOST=antigravity` (injetado por `mcp_config.json`) | `antigravity` |
 | nenhum | `generic` |
 
 ## Matriz de adapters
 
-| Concern | `claude` (Claude Code) | `codex` (Codex App) | `opencode` | `pi` (pi cli) | `generic` |
-|---------|------------------------|---------------------|------------|---------------|-----------|
-| Disparo de subagente | `Agent(subagent_type: "<name>", prompt: "<state_path>")` | `spawn_agent(agent_type: "<name>", items: [{ type: "text", text: "<state_path>" }])` | `@<name>` (ou auto) com `<state_path>` | tool `subagent({ agent: "<name>", task: "<state_path>", context: "fresh" })` (pi-subagents) | subagente nativo do host, passando só `<state_path>` |
-| Registro do subagente | `agents/<name>.md` na raiz do plugin | `CODEX_HOME/agents/<name>.toml` via `init codex` (`.codex/agents/` no bundle é fonte gerada; custom agent nativo; `developer_instructions` carrega o `SKILL.md`; `atlas-task-validator` pinado em `model="gpt-5.4"` + `model_reasoning_effort="high"`) | `.opencode/agents/<name>.md` (`mode: subagent`) | `.pi/agents/<name>.md` (pi-subagents; frontmatter `name`+`description`+`tools`; **`SKILL.md` canônico embutido no corpo** porque o pi não tem skill loader no sub-agente — fonte única segue `packages/skills/<name>/SKILL.md`, agente é cópia gerada por `build/gen-host-agent.mjs`) | mecanismo nativo equivalente |
-| Topologia do validador frio (G4) | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** |
-| Join síncrono (gate JOIN) | `self_evident` (`Agent()` bloqueante) | `self_evident` (confirmado em produção) | `self_evident` (`@<name>` bloqueante) | `must_report` (depende de `pi-subagents`; hard-fail sem report) | `must_report` (indeterminado; hard-fail sem report) |
-| Todo nativo | `TodoWrite` | `tasks` | `todowrite` | nenhum (segue sem mirror) | nenhum (segue sem mirror) |
-| Config MCP | `plugin.json` `mcpServers` | `.mcp.json` | `opencode.json` `mcp.<name>` (`type:"local"`, `environment.ATLAS_HOST=opencode`) | `.mcp.json` no root (`pi-mcp-adapter`; `env.ATLAS_HOST=pi`); tools chegam proxiadas/prefixadas `atlas_workflow_<tool>` | host MCP-capaz |
-| Deps externas obrigatórias | — | — | — | **`pi-mcp-adapter` + `pi-subagents`** (DEC-005) | — |
-| Estado de run | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) |
-| Escrita de plano | `.atlas/plans/` | `.atlas/plans/` | `.atlas/plans/` | `.atlas/plans/` | `.atlas/plans/` |
-| Leitura de plano (ordem) | `.atlas/plans/` → `.cursor/plans/` → `.codex/plans/` | idem | idem | idem | idem |
+| Concern | `claude` (Claude Code) | `codex` (Codex App) | `opencode` | `pi` (pi cli) | `antigravity` (Gemini) | `generic` |
+|---------|------------------------|---------------------|------------|---------------|------------------------|-----------|
+| Disparo de subagente | `Agent(subagent_type: "<name>", prompt: "<state_path>")` | `spawn_agent(agent_type: "<name>", items: [{ type: "text", text: "<state_path>" }])` | `@<name>` (ou auto) com `<state_path>` | tool `subagent({ agent: "<name>", task: "<state_path>", context: "fresh" })` (pi-subagents) | `define_subagent` + `invoke_subagent` com `<state_path>` | subagente nativo do host, passando só `<state_path>` |
+| Registro do subagente | `agents/<name>.md` na raiz do plugin | `CODEX_HOME/agents/<name>.toml` via `init codex` (`.codex/agents/` no bundle é fonte gerada; custom agent nativo; `developer_instructions` carrega o `SKILL.md`; `atlas-task-validator` pinado em `model="gpt-5.4"` + `model_reasoning_effort="high"`) | `.opencode/agents/<name>.md` (`mode: subagent`) | `.pi/agents/<name>.md` (pi-subagents; frontmatter `name`+`description`+`tools`; **`SKILL.md` canônico embutido no corpo** porque o pi não tem skill loader no sub-agente — fonte única segue `packages/skills/<name>/SKILL.md`, agente é cópia gerada por `build/gen-host-agent.mjs`) | dinâmico via `define_subagent` da skill do orquestrador | mecanismo nativo equivalente |
+| Topologia do validador frio (G4) | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** |
+| Join síncrono (gate JOIN) | `self_evident` (`Agent()` bloqueante) | `self_evident` (confirmado em produção) | `self_evident` (`@<name>` bloqueante) | `must_report` (depende de `pi-subagents`; hard-fail sem report) | `self_evident` (`invoke_subagent` bloqueante) | `must_report` (indeterminado; hard-fail sem report) |
+| Todo nativo | `TodoWrite` | `tasks` | `todowrite` | nenhum (segue sem mirror) | nenhum (segue sem mirror) | nenhum (segue sem mirror) |
+| Config MCP | `plugin.json` `mcpServers` | `.mcp.json` | `opencode.json` `mcp.<name>` (`type:"local"`, `environment.ATLAS_HOST=opencode`) | `.mcp.json` no root (`pi-mcp-adapter`; `env.ATLAS_HOST=pi`); tools chegam proxiadas/prefixadas `atlas_workflow_<tool>` | `mcp_config.json` (`env.ATLAS_HOST=antigravity`) | host MCP-capaz |
+| Deps externas obrigatórias | — | — | — | **`pi-mcp-adapter` + `pi-subagents`** (DEC-005) | — | — |
+| Estado de run | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) |
+| Escrita de plano | `.atlas/plans/` | `.atlas/plans/` | `.atlas/plans/` | `.atlas/plans/` | `.atlas/plans/` | `.atlas/plans/` |
+| Leitura de plano (ordem) | `.atlas/plans/` → `.cursor/plans/` → `.codex/plans/` | idem | idem | idem | idem | idem |
 
 `.cursor/plans/` e `.codex/plans/` são lidos com deprecation warning por 1 release; escrita só em `.atlas/plans/`. **opencode** instala via `.opencode/` + `opencode.json` (`hosts/opencode/`). **pi** instala via `mcp.json` + `agents/` + `skills/` (`hosts/pi/`) e exige as 2 deps obrigatórias; sem qualquer uma o preflight aborta (gate PREREQ).
 

package/hosts/pi/atlas/orchestrator/skills/atlas-workflow-orchestrator/SKILL.md

@@ -8,7 +8,7 @@ category: Development Automation
 
 Orquestra pipelines de desenvolvimento de features no projeto Atlas, automatizando a sequência de skills sob demanda com um único comando.
 
-> **v0.3 — MCP como fonte obrigatória de status.** Cada gate materializado deve ser consultado via MCP antes de avançar: `atlas_ping`, `atlas_preflight`, `atlas_verify_artifact`, `atlas_scan_prd`, `atlas_verify_template_conformance`, `atlas_lock_dispatch` e `atlas_assert_after_plan`. Sem resposta MCP, sem resultado exigido ou status bloqueante → workflow abortado, sem fallback narrativo. Edge cases de ambiente (conflito plugin/nativo, MCP indisponível, estado corrompido, lock conflict e drift de versão) bloqueiam com causa, impacto e próxima ação segura.
+> **MCP é fonte obrigatória de status.** Cada gate é consultado via MCP antes de avançar (tools por fase na Fase 0 e nos fluxos). Sem resposta MCP, sem resultado exigido ou status bloqueante → workflow abortado, sem fallback narrativo. Edge cases de ambiente (conflito plugin/nativo, MCP indisponível, estado corrompido, lock conflict, drift de versão) bloqueiam com causa, impacto e próxima ação segura.
 
 ## Sintaxe
 
@@ -124,33 +124,24 @@ A única interação legítima com o usuário é **dentro de uma fase** — o `A
 
 ## Papel do orquestrador (fronteira de determinismo pela mutação de código)
 
-O orquestrador **coordena a execução**, não implementa código. Pense nele como um maestro: aponta para cada músico (sub-agent) na ordem certa e espera cada um terminar. **Ele nunca pega o instrumento de código.**
+O orquestrador **coordena a execução**, não implementa código — maestro que aponta cada sub-agent na ordem e espera terminar, **nunca pega o instrumento de código**. A fronteira de determinismo é a **mutação de código** (PRD D10), com **duas fases**:
 
-A fronteira de determinismo é a **mutação de código** (PRD D10), e ela tem **duas fases** com regras diferentes:
+- **ANTES do plano validado — autoria documental livre no fio principal.** Pode autorar PRD, entrevistar e escrever `PLAN_*.md` direto; fases documentais não exigem sub-agent (documento não muta o produto). **Ao finalizar um PRD inline, estampar `| Status | Aprovado para implementação |`** — é o `required_status` do gate TC; sem isso o PRD sai `Draft` e trava o TC em rodadas de correção.
+- **DEPOIS do plano validado (`atlas_verify_artifact` + TC `passed`) — mãos atadas fortes.** Não edita mais PRD/plano/código nem roda comando mutante; só coordena (despachar sub-agent, ler artefato pra verificar gate, ecoar banner, montar output).
 
-- **ANTES do plano validado — autoria documental é livre no agente principal.** O orquestrador (agente principal) **pode** autorar o PRD, conduzir a entrevista e **escrever o `PLAN_*.md` diretamente**. Fases puramente documentais (gerar/maturar PRD, entrevistar, redigir plano) **não exigem** despacho de sub-agent. Documento não é código: autoria não muta o produto. **Ao autorar/finalizar um PRD no fio principal, estampar `| Status | Aprovado para implementação |`** — é o `required_status` que o gate TC exige (ver Validate PRD). Sem isso o PRD sai `Draft` e trava o TC em 2-3 rodadas de correção. (O `atlas-sprint-prd-generator` já faz isso; a autoria inline deve seguir igual.)
-- **DEPOIS do plano validado (`atlas_verify_artifact` + TC `passed`) — mãos atadas fortes.** A partir daí o orquestrador **NÃO** edita PRD/plano, **NÃO** edita código, **NÃO** roda comando mutante. Só **coordena a execução**: despachar sub-agent, ler artefato para verificar gate, ecoar banner, montar o output final.
-- **Execução de código é SEMPRE gateada — nunca afrouxa.** Toda mutação de código vive obrigatoriamente em sub-agent `plan_execute` (blocking, um por vez) + validador frio `task_validator` (PRD D10). O orquestrador **nunca escreve código**, em nenhuma fase, em nenhum modo. Isto não muda com a autoria documental livre acima.
-
-- **Permitido:** parse de args; classificar input; autorar PRD/entrevista/`PLAN_*.md` **enquanto o plano não foi validado**; despachar sub-agent (blocking, um por vez); ler artefato em disco para verificar gate; ecoar banner; montar o output final.
-- **Proibido (Gate G9):** escrever/editar **código**; rodar comando mutante (`flutter`, `test`, `git add/commit`); editar PRD/plano **depois** do plano validado; implementar "em paralelo"; usar `run_in_background` para fases do pipeline.
-- **Dispatch blocking:** despacha → **espera o retorno** → verifica gate → próxima fase. Nunca dois sub-agents simultâneos. Nunca trabalhar enquanto um sub-agent roda.
+Execução de código é **sempre** sub-agent `plan_execute` (blocking, um por vez) + validador frio `task_validator` (Gate G9/G7 — detalhe na tabela de gates). Dispatch blocking: despacha → espera retorno → verifica gate → próxima fase. Nunca dois sub-agents simultâneos.
 
 ### Verbo de dispatch é host-agnóstico (não assuma "Agent tool")
 
-O **mecanismo** de despacho de sub-agent **varia por host** — leia `subagent_dispatch.mechanism`, `.example` e `validator_dispatch` de `atlas_capabilities` e use o **verbo nativo do host**. Não hardcode o verbo do Claude. Mapeamento (ilustrativo; a fonte de verdade em runtime é `atlas_capabilities`):
+O **mecanismo** varia por host — leia `subagent_dispatch.mechanism`, `.example` e `validator_dispatch` de `atlas_capabilities` (fonte de verdade em runtime) e use o **verbo nativo**. Não hardcode o verbo do Claude. Mapeamento ilustrativo, onde `<exec>` é o id da fase (`plan-execute`/`direct-execute`/`slice-review`/`task-validator`):
 
 - **claude:** `Agent(subagent_type: "atlas-<exec>", prompt: ...)`
-- **codex:** `spawn_agent(agent_type: "atlas-<exec>", items: [{ type: "text", text: "<state_path ou task>" }])` usando custom agent nativo instalado em `CODEX_HOME/agents/atlas-<exec>.toml` pelo `init codex` (`.codex/agents/` no bundle é fonte gerada). Como em todo host, a topologia é **sibling**: o executor retorna `validator_handoff_required` com `state_path`, e o orquestrador despacha **explicitamente** `spawn_agent(agent_type: "atlas-task-validator", items: [{ type: "text", text: "<state_path>" }])` como sub-agent irmão isolado. O registro Codex do validator é gerado com `model = "gpt-5.4"` e `model_reasoning_effort = "high"`. Se `agent_type: "atlas-task-validator"` não existir no host, bloquear a slice (fail-closed); é proibido fallback para `default`, `$atlas-task-validator` ou validação inline.
+- **codex:** `spawn_agent(agent_type: "atlas-<exec>", items: [{ type: "text", text: "<state_path ou task>" }])` (custom agent nativo em `CODEX_HOME/agents/atlas-<exec>.toml`; `.codex/agents/` do bundle é gerado). `$atlas-*` sozinho **não** isola contexto — use `spawn_agent`.
 - **opencode:** `@atlas-<exec>` (ou auto por description)
 - **pi:** `subagent({ agent: "atlas-<exec>", task, context: "fresh" })`
 - **generic:** subagente nativo do host
 
-Onde `<exec>` é o id resolvido da fase (`plan-execute`, `direct-execute`, `slice-review`, `task-validator`).
-
-> **Rodar a mutação de código no fio principal é violação do Gate G9 — em QUALQUER host.** Ausência da "Agent tool" (porque o host não é Claude) **não** é licença para executar inline: é sinal de que você deve usar o **verbo de dispatch daquele host**. No Codex, `$atlas-*` sozinho não isola contexto; use `spawn_agent`. Se o host não expõe nenhum mecanismo de sub-agent (preflight `subagent_available:false`), o gate PREREQ já abortou em `ready` — você nunca chega aqui sem isolamento.
-
-Se você (orquestrador) está prestes a editar **código**, **pare**: esse trabalho é do sub-agent de execução. Despache-o (verbo nativo do host) e espere. (Autoria de PRD/plano antes da validação é a única autoria permitida no fio principal.)
+> Ausência de "Agent tool" (host ≠ Claude) **não** é licença pra executar inline — é sinal pra usar o verbo daquele host (Gate G9, qualquer host). Host sem mecanismo de sub-agent já abortou em PREREQ; você nunca chega aqui sem isolamento.
 
 ## Protocolo de banner (única comunicação de progresso)
 
@@ -177,6 +168,7 @@ Regras inegociáveis. Violação = parar, não contornar.
 | TC | **Conformidade de template via MCP.** PRD e PLAN só avançam como artefatos documentais se `atlas_verify_template_conformance` retornar `passed` e `pending_count: 0`. Pendência bloqueia com `next_action`. | PRD + plano |
 | G6 | **Status verificado, não auto-reportado.** O ✅ de cada item no output só pode ser marcado após confirmar o artefato em disco. Faltou artefato exigido pelo modo → status final `incomplete`, nunca `completed`. | output |
 | G7 | **Execução de código roda SEMPRE como sub-agent despachado (verbo nativo do host, lido de `atlas_capabilities`), nunca no contexto do orquestrador.** A **autoria** do `PLAN_*.md` pode ser feita pelo orquestrador no fio principal **enquanto o plano não foi validado** (autoria documental, PRD D10) — mas o plano só vira confiável após `atlas_verify_artifact` + TC `passed`. A **execução do plano** (`plan_execute`) e qualquer mutação de código vão obrigatoriamente a sub-agent. Antes de iniciar/concluir fase de execução, usar `atlas_lock_dispatch`; fase fora de ordem ou paralela bloqueia. Depois do plano validado, o orquestrador não edita mais o plano (mãos atadas fortes). | plano + execução |
+| G12 | **Executor vivo precisa provar progresso.** Ao iniciar `plan_execute`, `atlas_lock_dispatch(start)` cria liveness de bootstrap/progresso. O executor precisa emitir `atlas_lock_dispatch(checkpoint, phase=plan_execute, event=...)` cedo, começando por `executor_started`/`skill_loaded`, depois `plan_loaded`, `handoff_accepted`, `task_started`, `first_write` e `state_path_created` conforme avança. `state_path_created` exige `state_path` legível/parseável, e `atlas_lock_validator(start)` só abre validator se o último checkpoint for `state_path_created` para exatamente o mesmo `state_path`. Se o sub-agent não retornar, travar, ficar sem primeiro checkpoint, ou ficar com checkpoint antigo sem avanço, o orquestrador chama `atlas_lock_dispatch(action=status, phase=plan_execute)`: `executor_bootstrap_timeout`/`executor_progress_timeout` viram `stalled`, o lock é liberado para `retry_plan_execute`, e a execução não pode ser declarada completa. Sem checkpoint/progresso não há "em andamento" confiável. | execução |
 | G8 | **Ordem fixa de validação: `task-validator` ANTES, `slice-review` POR ÚLTIMO. Nunca em paralelo.** Conclusão de `plan_execute` usa `atlas_lock_dispatch` com `validator_status: passed`; review só inicia após execução concluída. | validação + review |
 | PREREQ | **Pré-requisitos de determinismo (hard-fail, DEC-004).** `atlas_preflight` verifica, **antes de tudo**, se o host tem subagente + MCP (essenciais). Ausente (ex.: pi sem `pi-mcp-adapter`/`pi-subagents`, host MCP-only sem subagente) → aborta em `ready` com `missing_prerequisites`/`next_action`. Sem degradação, sem validator inline, qualquer tamanho. `todo` não-essencial segue sem mirror. | roteamento |
 | DEP | **Dependência de backlog não satisfeita = hard-fail determinístico.** Se o input é `backlog-item` e o item declara `Dependências` (ex.: S40 dep S39) cujo status, lido no mesmo backlog/registro de onde o item veio, **não** é `done`, abortar em `ready` com `unmet_dependencies`, causa e `next_action` (executar a dependência primeiro). Sem improviso e sem pergunta: ou a dep está `done` e segue, ou bloqueia com causa. Não confundir com decisão em aberto (que não bloqueia). | roteamento (backlog-item) |
@@ -188,6 +180,10 @@ Regras inegociáveis. Violação = parar, não contornar.
 
 ## Fluxo de execução
 
+### [EXEC] — passo comum de execução + validação (idêntico em `full`/`direct`/`execute`)
+
+`atlas_lock_dispatch(action=start, phase=plan_execute)`; despachar `plan_execute` como sub-agent blocking (lê `PLAN_*.md` em `full`/`execute`, PRD em `direct`). O executor emite checkpoints G12; sem retorno/progresso, chamar `atlas_lock_dispatch(action=status, phase=plan_execute)` e tratar `executor_bootstrap_timeout`/`executor_progress_timeout` como `stalled`/retry — nunca como execução em andamento. O executor retorna `validator_handoff_required` com `state_path`; o MCP só abre o slot após o checkpoint `state_path_created` para esse mesmo `state_path`. Validação sempre **sibling**: `atlas_lock_validator(action=start)`, despachar **um** `task_validator`, exigir no output o `dispatch_token` do slot e fechar com `validator_run_id` + `dispatch_token`. Em `fail`: `repair_start`, despachar `atlas-findings-repair` com `{state_path, findings, validator_attempt, repair_run_id, repair_budget: 1}`, exigir atualização do mesmo `state_path`, fechar com `repair_run_id` e rodar o **2º e último** validator. `passed`/`passed_with_observations` são terminais aprovados; status diferente bloqueia review e output completed.
+
 ### Full mode
 
 Artefatos esperados (em ordem): `PRD_*.md` → (`PRD_*.md` atualizado) → `PLAN_*.md` → diff de código → relatório do validador.
@@ -199,7 +195,7 @@ Artefatos esperados (em ordem): `PRD_*.md` → (`PRD_*.md` atualizado) → `PLAN
 5. **Plan** — `atlas_lock_dispatch(action=start, phase=plan_handoff)`, carregar/invocar `plan_handoff` no fio principal para redigir `PLAN_*.md`, depois chamar `atlas_verify_artifact` e `atlas_verify_template_conformance(artifact_type=plan)`. Concluir a fase com `atlas_lock_dispatch(action=complete, phase=plan_handoff)`. **Nenhuma linha de código pode ter sido escrita até aqui.**
    - **G11:** se `PLAN_*.md` foi validado, chamar `atlas_assert_after_plan`. Se a próxima ação não for `dispatch_plan_execute_blocking`, abortar.
 6. **Validate plan** — se há gaps → dispara entrevista, propaga e continua (ver "Decisão em aberto ≠ parada"). Não para pra pedir permissão.
-7. **Execute** — `atlas_lock_dispatch(action=start, phase=plan_execute)`, despachar `plan_execute` como sub-agent lendo o `PLAN_*.md`. O executor retorna `validator_handoff_required` com `state_path`; o orquestrador abre um slot via `atlas_lock_validator(action=start)`, despacha **um** `task_validator`, exige no output o `dispatch_token` do slot e fecha com `validator_run_id` + `dispatch_token`. Se o veredito for `fail`, chama `repair_start`, despacha `atlas-findings-repair` com `{state_path, findings, validator_attempt, repair_run_id, repair_budget: 1}`, exige atualização do mesmo `state_path`, fecha com `repair_run_id` e só então roda o **2º e último** validator. Ao obter `passed` ou `passed_with_observations`, conclui `plan_execute` com o terminal. Status diferente bloqueia review e output completed.
+7. **Execute** — rodar o passo **[EXEC]** (lê `PLAN_*.md`).
 8. **Review (condicional)** — somente após execução concluída e se `--review` → `atlas_lock_dispatch(action=start, phase=slice_review)`, despachar `slice_review`, depois `atlas_lock_dispatch(action=complete, phase=slice_review)`.
 9. **Output** — ledger verificado com fonte MCP por gate/fase (ver "Output") + próximos passos.
 
@@ -209,7 +205,7 @@ Artefatos esperados: `PRD_*.md` → (atualizado) → diff de código → relató
 
 1. Parse / Generate PRD (se necessário) + `atlas_verify_artifact`.
 2. Validate PRD → `atlas_scan_prd` + `atlas_verify_template_conformance`; entrevista condicional reexecuta os gates.
-3. **Execute** — `atlas_lock_dispatch(action=start, phase=plan_execute)`; despachar `plan_execute` como sub-agent blocking a partir do PRD. O executor retorna `validator_handoff_required` com `state_path`; o orquestrador abre o slot, despacha o validator e fecha usando `validator_run_id` + `dispatch_token`. Em `fail`, abre repair, passa `{state_path, findings, validator_attempt, repair_run_id, repair_budget: 1}` ao `atlas-findings-repair`, mantém o mesmo `state_path`, fecha o repair e roda o **2º e último** validator. `passed` e `passed_with_observations` são terminais aprovados.
+3. **Execute** — rodar o passo **[EXEC]** (executor lê o PRD; sem `PLAN_*.md`).
 4. Review (condicional) — só após executor retornar 100% e dispatch MCP permitir.
 5. Output (ledger verificado).
 
@@ -221,7 +217,7 @@ Entrada: um **`PLAN_*.md` pronto**. Artefatos esperados: (plano já existe) →
 
 1. **Parse / classify** — `atlas_ping` → `atlas_capabilities` → **`atlas_classify_input`** no input (PRD D3/D6: o tipo é fato e precisa ser conhecido antes de travar o modo) → **`atlas_preflight(<modo efetivo>)`** (PREREQ hard-fail intacto). A classificação determina o tipo: se for plano, o modo efetivo é `execute` e o preflight trava `execute`; se o input não for plano, auto-rotear (ver Fase 0, passo 2b) e o preflight trava o modo roteado. **`classify_input` sempre precede `preflight`** (o preflight trava o modo efetivo, não o pedido).
 2. **Reverificar o plano na entrada** — `atlas_verify_artifact` no `PLAN_*.md` (G1) + `atlas_verify_template_conformance(artifact_type=plan)` (TC). Plano velho/manual/inválido **trava aqui** com `next_action` em linguagem de produto (PRD D11 — "autoria é livre, execução é gateada"). Sem reverificação válida não há dispatch.
-3. **Executar** — `atlas_lock_dispatch(action=start, phase=plan_execute)`; despachar `plan_execute` como sub-agent blocking lendo o `PLAN_*.md`. A validação é sempre **sibling**: o executor escreve `state_path` e para; o orquestrador despacha o validator via `atlas_lock_validator` e fecha o slot somente com `validator_run_id` + `dispatch_token`. Ao obter `passed` ou `passed_with_observations`, concluir `plan_execute` com o terminal correspondente. `plan_execute` é aceito como **primeira fase** em `execute` (sem fase nova; PRD D13).
+3. **Executar** — rodar o passo **[EXEC]** (lê `PLAN_*.md`). `plan_execute` é aceito como **primeira fase** em `execute` (sem fase nova; PRD D13).
 4. **Review (condicional)** — só após execução concluída e se `--review` → `atlas_lock_dispatch(action=start, phase=slice_review)`, despachar `slice_review`, depois `complete`.
 5. **Output** — ledger verificado; `guarantee_level` = `full_pipeline` (PRD D12).
 
@@ -238,15 +234,7 @@ Entrada: um **`PLAN_*.md` pronto**. Artefatos esperados: (plano já existe) →
 
 ## Validação automática de PRD
 
-O scan é **determinístico**. Marca ambiguidade quando uma seção contém qualquer padrão abaixo (lista canônica embutida no MCP):
-
-- **§1 Contexto e objetivo:** `TBD`, `a confirmar`, `talvez`, `não definido`
-- **§2 Escopo:** `pode ser`, `depende de`, `ainda não`, `incompleto`
-- **§3 Decisões:** vazio/conteúdo mínimo, `vago`
-- **§4 Fluxos e cenários UX:** `a definir`, `gap`, `depende de`
-- **§5 Contrato funcional e invariantes:** `ainda não definido`, `mock apenas`, `a confirmar`
-
-Antes de contar bloqueantes, aplicar exclusões estreitas do config (`exclude_if_line_contains`, hoje `depende de plano`) para frases de sucesso/resultado que descrevem dependência operacional já planejada. Não usar julgamento livre: a exclusão precisa estar no config e ser logada.
+O scan é **determinístico** e roda **dentro do MCP** (`atlas_scan_prd`): a lista canônica de padrões §1-§5 e as exclusões de config (`exclude_if_line_contains`) são embutidas e mantidas no servidor — o orquestrador **não** reaplica padrões por conta própria, só consome o resultado. Não usar julgamento livre.
 
 **Threshold = 1.** Se ≥ 1 padrão bloqueante → o orquestrador invoca `atlas-prd-interview` no fio principal. **Gate G5:** se 0 padrões bloqueantes, registrar `Ambiguity scan: 0 padrões bloqueantes — entrevista pulada` no output. Não há decisão subjetiva de "tenho certeza, pulo".
 
@@ -254,16 +242,16 @@ Antes de contar bloqueantes, aplicar exclusões estreitas do config (`exclude_if
 
 ## Decisão em aberto ≠ parada
 
-Decisão pendente **não bloqueia o pipeline** e **não vira menu de permissão**. Vale para **qualquer fonte** onde a decisão apareça — scan de PRD, entrevista, validação de plano, `PERGUNTAS_EM_ABERTO.md`, doc de discussão/decisões (ex.: `DISCUSSAO_*.md`) ou o próprio backlog. A fonte não muda o tratamento.
+Detalhe do caminho que a "Princípio de continuação automática" exige para decisão pendente de **qualquer fonte** (scan/entrevista/validação de plano/`PERGUNTAS_EM_ABERTO.md`/`DISCUSSAO_*.md`/backlog — a fonte não muda o tratamento):
 
-Caminho determinístico:
+1. **Garantir o PRD primeiro.** Em `full`/`direct`, se o PRD não existe, **gerar o PRD draft** com as decisões marcadas. A entrevista é **PRD-scoped**: roda **sobre** o PRD, nunca antes. Detectar decisão não antecipa nem pula a geração do PRD.
+2. **Disparar `atlas-prd-interview`** sobre o PRD — resolve via `AskUserQuestion` (interação dentro da fase, não pedido de permissão).
+3. **Propagar** ao PRD/plano/DEC/registro de origem.
+4. **Reexecutar** os gates afetados (`atlas_verify_artifact`/`atlas_scan_prd`/TC) e **continuar** automaticamente.
 
-1. **Garantir o PRD primeiro.** Em `full`/`direct`, se o PRD ainda não existe, **gerar o PRD draft** (passo "Generate PRD", automático — ver "Princípio de continuação automática") com as decisões marcadas. A entrevista é **PRD-scoped**: roda **sobre** o PRD, nunca antes dele. Detectar decisão **não** antecipa nem pula a geração do PRD — primeiro materializa o PRD, depois resolve nele.
-2. **Disparar `atlas-prd-interview`** sobre o PRD — resolve a decisão via `AskUserQuestion` (interação **dentro da fase**, não pedido de permissão pra avançar).
-3. **Propagar** a resolução ao PRD/plano/DEC/registro de origem.
-4. **Reexecutar** os gates afetados (`atlas_verify_artifact`/`atlas_scan_prd`/TC) e **continuar** (plano→execução) automaticamente.
+Marcar TBD e adiar só se o usuário pedir **explicitamente** — nunca por iniciativa do orquestrador.
 
-O default é **gerar PRD, resolver via entrevista e seguir**. Não existe ponto de parada "A) resolver / B) seguir com TBD / C) adiar" como rotina do pipeline, nem "responda só: seguir com recomendação ou D=...". Marcar TBD e adiar só se o usuário pedir **explicitamente** no fio — nunca por iniciativa do orquestrador. A única parada é gate duro `blocked` (ver "Princípio de continuação automática").
+> `PERGUNTAS_EM_ABERTO.md` é verificado na validação de PRD; Q- aberta da sprint **não é blockage** — entra neste mesmo caminho.
 
 ---
 
@@ -324,12 +312,6 @@ Se `full` gerou `PLAN_*.md` mas não despachou `plan_execute`, o cabeçalho deve
 
 ---
 
-## Integração com PERGUNTAS_EM_ABERTO.md
-
-Plugin verifica `PERGUNTAS_EM_ABERTO.md` durante validação de PRD. Q-… abertas relacionadas à sprint **não param o pipeline** (Q- aberta não é blockage). O orquestrador trata como decisão em aberto: dispara `atlas-prd-interview` para resolver, propaga a decisão (PRD/plano/DEC/registro) e **continua** o pipeline. Ver "Decisão em aberto ≠ parada".
-
----
-
 ## Error handling
 
 - **Pré-flight falha (skill ausente no host)** → para, reporta, não emula (ver Fase 0).
@@ -399,14 +381,4 @@ orquestrador
 
 Regra de ouro: **um sub-agent por fase de execução, em série, blocking, sustentado por MCP**. O orquestrador espera cada sub-agent terminar antes do próximo e **nunca** trabalha em paralelo nem escreve código (Gate G9). Autoria documental (PRD/plano) é livre no fio principal **antes** do plano validado; depois, mãos atadas. Em `full`, `PLAN_*.md` validado obriga `plan_execute` no mesmo workflow (G11). `task-validator` ⟂ `slice-review` jamais coexistem. Progresso só por banner (string do MCP).
 
-> Histórico completo (todas as versões, com detalhe de cada correção) vive em [`CHANGELOG.md`](../../../../CHANGELOG.md) na raiz do repo — fonte canônica. Abaixo só as entradas recentes relevantes ao contrato do orquestrador.
-
-- **v0.8.1** — Patch de confiabilidade de contrato (só SKILL/command; sem código MCP, sem schema, schema v5 intacto). Fecha o vazamento de **parada discricionária**: nova seção "Princípio de continuação automática" (pipeline fire-and-continue — só para em gate duro `blocked` ou blockage de ambiente real) + "Decisão em aberto ≠ parada" (decisão pendente de **qualquer fonte** — scan/entrevista/`PERGUNTAS_EM_ABERTO.md`/`DISCUSSAO_*.md`/backlog — dispara entrevista, propaga e **continua**, nunca vira menu de permissão nem "responda só: seguir ou D=..."; sequência travada: em `full`/`direct` gera PRD draft **primeiro**, entrevista roda **sobre** o PRD). Proíbe modo fora do contrato ("Modo Discussão"/"dry-run") e "quer que eu gere/continue?"; PRD ausente em `full`/`direct` gera automático. Novo **Gate DEP**: dependência de backlog não-`done` é hard-fail determinístico (não confundir com decisão em aberto). Origem: relato de pausa indevida no pipeline (orquestrador parava pra pedir confirmação que o contrato não exige).
-- **v0.8.0** — Proof-of-work do validador frio (Gate G4, R20). `atlas_lock_validator(start)` emite um `challenge` (sha256 de um arquivo do boundary do `state_path`); o validador irmão lê via `validator_recovery.challenge`, computa o hash e devolve em `challenge_response`; o `complete` recomputa do disco e bloqueia (`challenge_failed`, slot preservado) em divergência/ausência. Atestação mecânica de que o veredito leu o boundary — fecha o atalho preguiçoso de afirmar `pass` sem ler código. **Não** é prova de isolamento não-forjável (MCP fala stdio com um único caller); best-effort (boundary sem arquivo legível → sem challenge, sem enforcement). Schema `atlas_capabilities` intacto (v5).
-- **v0.7.2** — Patch de confiabilidade (sem breaking, schema v5 intacto). `ping().capabilities` passa a ser **derivado de `toolsList()`** (fonte única) — fim do drift que omitia `atlas_classify_input`, capaz de travar run válida na Fase 0; guard cruzado novo. CI ganha job `cross-os` (Windows/macOS, Node puro). Doc: proveniência do `dispatch_token` no `atlas-task-validator` e `.gitattributes` marcando artefatos gerados.
-- **v0.7.1** — Patch de confiabilidade. MCP: `atlas_run_state(upsert)` faz merge top-level (não derruba `dispatch.active`); `findActiveRunConflict` só bloqueia conflito de lock real; `atlas_verify_artifact` aceita `artifact_kind`. Gate G4 endurecido: falha de dispatch em runtime = `blocked`, nunca inline (R17); `dispatch_token` do `complete` vem do output do próprio validador irmão (R19).
-
-## Próximas fases
-
-- **v0.4** hardening de empacotamento e smoke multi-host
-- **v1.0** contrato estável de workflow
+> Histórico de versões (detalhe de cada correção) e roadmap: [`CHANGELOG.md`](../../../../CHANGELOG.md) na raiz — fonte canônica.