atlas-workflow 0.8.2 → 0.8.3

package/README.md

@@ -1,8 +1,8 @@
 # Atlas Workflow
 
-Plugin **Atlas Workflow Orchestrator** v0.8.2 — pipeline determinístico (PRD → plano → execução → validação) com skills `atlas-*`, templates e MCP. Um pacote, cinco hosts: **Claude Code**, **Cursor**, **Codex App**, **OpenCode** e **Pi CLI**.
+Plugin **Atlas Workflow Orchestrator** v0.8.3 — pipeline determinístico (PRD → plano → execução → validação) com skills `atlas-*`, templates e MCP. Um pacote, cinco hosts: **Claude Code**, **Cursor**, **Codex App**, **OpenCode** e **Pi CLI**.
 
-**Versão:** [`VERSION`](VERSION) (`0.8.2`) · **Repo:** https://github.com/pauloborini/atlas-workflow
+**Versão:** [`VERSION`](VERSION) (`0.8.3`) · **Repo:** https://github.com/pauloborini/atlas-workflow
 
 ## Hosts
 

package/VERSION

@@ -1 +1 @@
-0.8.2
+0.8.3

package/build/bump-version.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// Bump determinístico de versão. Sincroniza os arquivos com versão concreta,
+// regenera bundles/catálogos e roda check-consistency. NÃO cria tag nem commita
+// — quem publica é o workflow Release ao detectar VERSION novo na main.
+//
+// Uso: node build/bump-version.mjs <nova-versao>   (ex.: 0.8.3)
+//
+// Não toca CHANGELOG.md nem PATCH_PROCEDURE.md (prosa/exemplos históricos), nem
+// a seção "Novidades vX" do orchestrator README (changelog embutido). Esses são
+// passos narrativos manuais, listados no final.
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const next = (process.argv[2] || '').trim();
+
+function die(msg) { console.error(`bump-version: ${msg}`); process.exit(1); }
+
+if (!/^\d+\.\d+\.\d+$/.test(next)) {
+  die(`versão inválida "${process.argv[2] || ''}" — use SemVer X.Y.Z (ex.: 0.8.3)`);
+}
+
+const versionPath = path.join(ROOT, 'VERSION');
+const current = fs.readFileSync(versionPath, 'utf8').trim();
+if (current === next) die(`VERSION já é ${next} — nada a bumpar`);
+
+const esc = current.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+// [arquivo, transform]. transform recebe o conteúdo e devolve o novo.
+const edits = [
+  ['VERSION', () => `${next}\n`],
+  ['package.json', (t) => replaceOnce(t, `"version": "${current}"`, `"version": "${next}"`, 'package.json')],
+  ['packages/mcp-server/package.json', (t) => replaceOnce(t, `"version": "${current}"`, `"version": "${next}"`, 'mcp-server/package.json')],
+  ['.claude-plugin/plugin.json', (t) => replaceOnce(t, `"version": "${current}"`, `"version": "${next}"`, '.claude-plugin/plugin.json')],
+  // Prosa de versão atual — replace-all é seguro (sem changelog embutido).
+  ['README.md', (t) => replaceAll(t, esc, next, 'README.md')],
+  ['COMMANDS.md', (t) => replaceAll(t, esc, next, 'COMMANDS.md')],
+  ['packages/mcp-server/README.md', (t) => replaceAll(t, esc, next, 'mcp-server/README.md')],
+  // Orchestrator README tem "Novidades vX" (histórico) — só a linha Plugin version.
+  ['packages/orchestrator/README.md', (t) => replaceOnce(t, `**Plugin version:** ${current}`, `**Plugin version:** ${next}`, 'orchestrator/README.md (Plugin version)')],
+];
+
+function replaceOnce(text, from, to, label) {
+  if (!text.includes(from)) die(`âncora não encontrada em ${label}: "${from}"`);
+  return text.replace(from, to);
+}
+function replaceAll(text, escFrom, to, label) {
+  const re = new RegExp(escFrom, 'g');
+  if (!re.test(text)) die(`versão ${current} não encontrada em ${label}`);
+  return text.replace(new RegExp(escFrom, 'g'), to);
+}
+
+for (const [rel, fn] of edits) {
+  const p = path.join(ROOT, rel);
+  const before = fs.readFileSync(p, 'utf8');
+  fs.writeFileSync(p, fn(before));
+  console.log(`  bump  ${rel}  ${current} -> ${next}`);
+}
+
+console.log(`\nRegenerando bundles/catálogos (build-plugins.sh)…`);
+execFileSync('bash', [path.join(ROOT, 'build', 'build-plugins.sh')], { cwd: ROOT, stdio: 'inherit' });
+
+console.log(`Rodando check-consistency…`);
+execFileSync('node', [path.join(ROOT, 'build', 'check-consistency.mjs')], { cwd: ROOT, stdio: 'inherit' });
+
+console.log(`\nbump-version: ${current} -> ${next} OK.
+
+Passos narrativos manuais (não automatizáveis):
+  1. CHANGELOG.md — adicionar entrada "## ${next} - YYYY-MM-DD".
+  2. packages/orchestrator/README.md — adicionar seção "### Novidades v${next}" e "Last updated".
+  3. Revisar 'git status', commitar e dar push na main.
+     => VERSION novo na main dispara Release (tag + npm + GitHub release) sozinho.`);

package/hosts/opencode/.opencode/atlas/VERSION

@@ -1 +1 @@
-0.8.2
+0.8.3

package/hosts/opencode/.opencode/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.8.3
 **Author:** Paulo Borini
-**Last updated:** 2026-06-15
+**Last updated:** 2026-06-16
+
+### Novidades v0.8.3 — 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/opencode/.opencode/atlas/orchestrator/skills/atlas-workflow-orchestrator/SKILL.md

@@ -177,6 +177,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) |
@@ -199,7 +200,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** — `atlas_lock_dispatch(action=start, phase=plan_execute)`, despachar `plan_execute` como sub-agent lendo o `PLAN_*.md`. O executor precisa emitir checkpoints G12; se o dispatch não retornar ou não produzir primeiro checkpoint/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`; antes de abrir validator, o MCP exige checkpoint `state_path_created` para esse mesmo `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.
 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 +210,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** — `atlas_lock_dispatch(action=start, phase=plan_execute)`; despachar `plan_execute` como sub-agent blocking a partir do PRD. Exigir checkpoints G12; sem retorno/progresso, chamar `atlas_lock_dispatch(action=status, phase=plan_execute)` e bloquear/retry em `executor_bootstrap_timeout`/`executor_progress_timeout`. O executor retorna `validator_handoff_required` com `state_path`; o MCP só abre o slot após `state_path_created` para o mesmo `state_path`; então o orquestrador 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.
 4. Review (condicional) — só após executor retornar 100% e dispatch MCP permitir.
 5. Output (ledger verificado).
 
@@ -221,7 +222,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** — `atlas_lock_dispatch(action=start, phase=plan_execute)`; despachar `plan_execute` como sub-agent blocking lendo o `PLAN_*.md`. Exigir checkpoints G12; se o executor não devolver retorno/progresso, chamar `atlas_lock_dispatch(action=status, phase=plan_execute)` e bloquear/retry em `executor_bootstrap_timeout`/`executor_progress_timeout`. A validação é sempre **sibling**: o executor escreve `state_path`, emite `state_path_created` e para; o MCP só abre validator para esse mesmo `state_path`; 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).
 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).
 

package/hosts/opencode/.opencode/atlas/packages/mcp-server/README.md

@@ -1,6 +1,6 @@
 # Atlas Workflow MCP Server
 
-Servidor MCP do plugin Atlas Workflow v0.8.2.
+Servidor MCP do plugin Atlas Workflow v0.8.3.
 
 ## Tools
 
@@ -12,7 +12,7 @@ Servidor MCP do plugin Atlas Workflow v0.8.2.
 - `atlas_verify_template_conformance`: Gate TC; PRD/PLAN só avançam com template conforme e `pending_count: 0`.
 - `atlas_scan_prd`: Gate G5; escaneia PRD por padrões determinísticos de ambiguidade bloqueante.
 - `atlas_preflight`: Gate G10; valida modo, versão, lock ativo e mapa oficial de skills atlas-*.
-- `atlas_lock_dispatch`: Gates G7/G8; controla fase ativa, ordem de dispatch e validator antes de review.
+- `atlas_lock_dispatch`: Gates G7/G8/G12; controla fase ativa, checkpoints de liveness do executor, ordem de dispatch e validator antes de review (`state_path_created` exige `state_path` legível).
 - `atlas_lock_validator`: Gate G4 sibling; um validator por vez, `dispatch_token` obrigatório, máximo de 2 attempts, repair obrigatório entre fail e retry, proof-of-work (challenge sha256 do boundary recomputado no complete; re-dispatch bounded → `challenge_exhausted`).
 - `atlas_assert_after_plan`: Gate G11; bloqueia encerramento prematuro do modo full após plano validado.
 
@@ -25,4 +25,5 @@ Servidor MCP do plugin Atlas Workflow v0.8.2.
 - Gates: resultados persistidos em `data.gates`.
 - Roteamento: lock persistido em `data.routing`.
 - Dispatch: fase ativa, próxima ação e histórico persistidos em `data.dispatch`.
+- Liveness: `plan_execute` persiste `data.dispatch.active.liveness`; bootstrap vencido sem checkpoint ou checkpoint antigo sem progresso vira `executor_liveness.status = stalled` e `next_action: retry_plan_execute`; `atlas_lock_validator(start)` bloqueia até `state_path_created` corresponder ao mesmo `state_path`.
 - Erro bloqueante: entradas inválidas, run inexistente ou falha de estado retornam erro JSON-RPC; gate bloqueado retorna `status: "blocked"` e `next_action`.

package/hosts/opencode/.opencode/atlas/packages/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlas-workflow/mcp-server",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "private": true,
   "type": "module",
   "bin": {

package/hosts/opencode/.opencode/atlas/packages/mcp-server/server.js

@@ -78,6 +78,17 @@ const VALIDATOR_MAX_ATTEMPTS = 2;
 // bloqueia com causa explícita em vez de re-despachar indefinidamente.
 const VALIDATOR_CHALLENGE_MAX_FAILURES = 2;
 const VALIDATOR_PASSED_STATUSES = new Set(['passed', 'passed_with_observations']);
+const EXECUTOR_BOOTSTRAP_TIMEOUT_MS = 120_000;
+const EXECUTOR_PROGRESS_TIMEOUT_MS = 300_000;
+const EXECUTOR_CHECKPOINT_EVENTS = new Set([
+  'executor_started',
+  'skill_loaded',
+  'plan_loaded',
+  'handoff_accepted',
+  'task_started',
+  'first_write',
+  'state_path_created',
+]);
 
 function validatorRunId(runId, attempt, timestamp) {
   return `${runId}:validator:${attempt}:${timestamp}`;
@@ -584,6 +595,11 @@ function nowIso() {
   return new Date().toISOString();
 }
 
+function isoPlusMs(iso, ms) {
+  const base = Date.parse(iso);
+  return new Date((Number.isFinite(base) ? base : Date.now()) + ms).toISOString();
+}
+
 function redact(value) {
   if (Array.isArray(value)) return value.map(redact);
   if (!value || typeof value !== 'object') return value;
@@ -882,6 +898,7 @@ function patchDispatchResult(runId, result, args = {}) {
       timestamp: result.timestamp,
       phase: result.phase ?? null,
       action: result.action ?? null,
+      event: result.event ?? null,
       status: result.status,
       next_action: result.next_action ?? null,
       error: result.error ?? null,
@@ -1693,6 +1710,27 @@ function expectedNextPhase(routing, dispatch) {
   return 'prd_interview';
 }
 
+function initialExecutorLiveness(timestamp) {
+  return {
+    status: 'spawned',
+    bootstrap_timeout_ms: EXECUTOR_BOOTSTRAP_TIMEOUT_MS,
+    progress_timeout_ms: EXECUTOR_PROGRESS_TIMEOUT_MS,
+    bootstrap_deadline_at: isoPlusMs(timestamp, EXECUTOR_BOOTSTRAP_TIMEOUT_MS),
+    next_progress_deadline_at: null,
+    required_first_checkpoint: 'executor_started',
+    last_checkpoint: null,
+    last_progress_at: null,
+    checkpoints: [],
+  };
+}
+
+function checkpointStatus(event) {
+  if (event === 'state_path_created') return 'handoff_ready';
+  if (event === 'task_started' || event === 'first_write') return 'executing';
+  if (event === 'plan_loaded' || event === 'handoff_accepted') return 'ready';
+  return 'booting';
+}
+
 function startDispatch(args, context) {
   const phase = requiredString(args, 'phase');
   if (Object.prototype.hasOwnProperty.call(args, LEGACY_ROUTE_KEY)) {
@@ -1752,7 +1790,11 @@ function startDispatch(args, context) {
     current_phase: phase,
     expected_phase: expected,
     dispatch: {
-      active: { phase, started_at: timestamp },
+      active: {
+        phase,
+        started_at: timestamp,
+        ...(phase === 'plan_execute' ? { liveness: initialExecutorLiveness(timestamp) } : {}),
+      },
       previous_phase: context.dispatch.previous_phase ?? null,
       next_phase: null,
       next_action: `complete_${phase}`,
@@ -1761,6 +1803,220 @@ function startDispatch(args, context) {
   };
 }
 
+function checkpointDispatch(args, context) {
+  const phase = requiredString(args, 'phase');
+  const event = requiredString(args, 'event');
+  const timestamp = nowIso();
+  const active = context.dispatch.active;
+
+  if (phase !== 'plan_execute') {
+    return {
+      gate: 'G12',
+      action: 'checkpoint',
+      phase,
+      event,
+      status: 'blocked',
+      timestamp,
+      error: 'Checkpoint de liveness só se aplica a plan_execute',
+      current_phase: active?.phase ?? null,
+      expected_phase: 'plan_execute',
+      next_action: 'corrigir_fase_do_checkpoint',
+    };
+  }
+  if (!active || active.phase !== phase) {
+    return {
+      gate: 'G12',
+      action: 'checkpoint',
+      phase,
+      event,
+      status: 'blocked',
+      timestamp,
+      error: `Checkpoint fora de ordem: fase ativa ${active?.phase ?? 'nenhuma'}, recebido ${phase}`,
+      current_phase: active?.phase ?? null,
+      expected_phase: active?.phase ?? expectedNextPhase(context.routing, context.dispatch),
+      next_action: active ? `checkpoint_${active.phase}` : `dispatch_${expectedNextPhase(context.routing, context.dispatch)}`,
+    };
+  }
+  if (!EXECUTOR_CHECKPOINT_EVENTS.has(event)) {
+    return {
+      gate: 'G12',
+      action: 'checkpoint',
+      phase,
+      event,
+      status: 'blocked',
+      timestamp,
+      error: `Checkpoint desconhecido: ${event}`,
+      current_phase: phase,
+      expected_phase: phase,
+      next_action: 'emitir_checkpoint_executor_valido',
+    };
+  }
+
+  const planPath = optionalString(args, 'plan_path');
+  const statePathValue = optionalString(args, 'state_path');
+  const detail = optionalString(args, 'detail');
+  if (event === 'state_path_created') {
+    if (!statePathValue || statePathValue.trim() === '') {
+      return {
+        gate: 'G12',
+        action: 'checkpoint',
+        phase,
+        event,
+        status: 'blocked',
+        timestamp,
+        error: 'state_path obrigatório para checkpoint state_path_created',
+        current_phase: phase,
+        expected_phase: phase,
+        next_action: 'emitir_state_path_created_com_state_path',
+      };
+    }
+    try {
+      JSON.parse(fs.readFileSync(resolveConsumerPath(statePathValue, args), 'utf8'));
+    } catch (error) {
+      return {
+        gate: 'G12',
+        action: 'checkpoint',
+        phase,
+        event,
+        status: 'blocked',
+        timestamp,
+        error: `state_path inválido ou ilegível para checkpoint state_path_created: ${error.message}`,
+        current_phase: phase,
+        expected_phase: phase,
+        next_action: 'corrigir_state_path_antes_do_handoff',
+      };
+    }
+  }
+  const liveness = active.liveness && typeof active.liveness === 'object'
+    ? active.liveness
+    : initialExecutorLiveness(active.started_at ?? timestamp);
+  const checkpoint = {
+    event,
+    timestamp,
+    ...(planPath ? { plan_path: planPath } : {}),
+    ...(statePathValue ? { state_path: statePathValue } : {}),
+    ...(detail ? { detail } : {}),
+  };
+  const nextLiveness = {
+    ...liveness,
+    status: checkpointStatus(event),
+    last_checkpoint: event,
+    last_progress_at: timestamp,
+    next_progress_deadline_at: isoPlusMs(timestamp, EXECUTOR_PROGRESS_TIMEOUT_MS),
+    checkpoints: [
+      ...(Array.isArray(liveness.checkpoints) ? liveness.checkpoints : []),
+      checkpoint,
+    ],
+  };
+
+  return {
+    gate: 'G12',
+    action: 'checkpoint',
+    phase,
+    event,
+    status: 'passed',
+    timestamp,
+    executor_liveness: nextLiveness.status,
+    current_phase: phase,
+    expected_phase: phase,
+    dispatch: {
+      active: {
+        ...active,
+        liveness: nextLiveness,
+      },
+      executor_liveness: nextLiveness,
+      next_action: `complete_${phase}`,
+    },
+    next_action: `continue_${phase}`,
+  };
+}
+
+function statusDispatch(args, context) {
+  const phase = requiredString(args, 'phase');
+  const timestamp = nowIso();
+  const active = context.dispatch.active;
+
+  if (!active || active.phase !== phase) {
+    return {
+      gate: 'G12',
+      action: 'status',
+      phase,
+      status: 'blocked',
+      timestamp,
+      error: `Status fora de ordem: fase ativa ${active?.phase ?? 'nenhuma'}, recebido ${phase}`,
+      current_phase: active?.phase ?? null,
+      expected_phase: active?.phase ?? expectedNextPhase(context.routing, context.dispatch),
+      next_action: active ? `status_${active.phase}` : `dispatch_${expectedNextPhase(context.routing, context.dispatch)}`,
+    };
+  }
+
+  const liveness = active.liveness && typeof active.liveness === 'object'
+    ? active.liveness
+    : (phase === 'plan_execute' ? initialExecutorLiveness(active.started_at ?? timestamp) : null);
+  const checkpoints = Array.isArray(liveness?.checkpoints) ? liveness.checkpoints : [];
+  const deadline = Date.parse(liveness?.bootstrap_deadline_at ?? '');
+  const now = Date.parse(timestamp);
+  const bootstrapExpired = phase === 'plan_execute'
+    && checkpoints.length === 0
+    && Number.isFinite(deadline)
+    && Number.isFinite(now)
+    && now > deadline;
+  const progressDeadline = Date.parse(liveness?.next_progress_deadline_at ?? '');
+  const progressExpired = phase === 'plan_execute'
+    && checkpoints.length > 0
+    && Number.isFinite(progressDeadline)
+    && Number.isFinite(now)
+    && now > progressDeadline;
+
+  if (bootstrapExpired || progressExpired) {
+    const cause = bootstrapExpired ? 'executor_bootstrap_timeout' : 'executor_progress_timeout';
+    const stalledLiveness = {
+      ...liveness,
+      status: 'stalled',
+      stalled_at: timestamp,
+      cause,
+    };
+    return {
+      gate: 'G12',
+      action: 'status',
+      phase,
+      status: 'blocked',
+      timestamp,
+      cause,
+      error: bootstrapExpired
+        ? `Executor sem checkpoint até ${liveness.bootstrap_deadline_at}`
+        : `Executor sem progresso desde ${liveness.last_progress_at}`,
+      current_phase: phase,
+      expected_phase: phase,
+      dispatch: {
+        active: null,
+        previous_phase: phase,
+        next_phase: phase,
+        next_action: `retry_${phase}`,
+        executor_liveness: stalledLiveness,
+      },
+      next_action: `retry_${phase}`,
+    };
+  }
+
+  return {
+    gate: 'G12',
+    action: 'status',
+    phase,
+    status: 'passed',
+    timestamp,
+    executor_liveness: liveness?.status ?? 'not_tracked',
+    current_phase: phase,
+    expected_phase: phase,
+    dispatch: {
+      active: liveness ? { ...active, liveness } : active,
+      executor_liveness: liveness,
+      next_action: `complete_${phase}`,
+    },
+    next_action: `complete_${phase}`,
+  };
+}
+
 function completeDispatch(args, context) {
   const phase = requiredString(args, 'phase');
   const timestamp = nowIso();
@@ -1896,13 +2152,15 @@ function lockDispatch(args = {}) {
     throw rpcError(-32602, `unknown_property: ${LEGACY_ROUTE_KEY}`);
   }
   const action = args.action ?? 'start';
-  if (!['start', 'complete', 'abort'].includes(action)) {
+  if (!['start', 'checkpoint', 'status', 'complete', 'abort'].includes(action)) {
     throw rpcError(-32602, `Ação inválida para atlas_lock_dispatch: ${action}`);
   }
 
   const context = getDispatchState(runId, args);
   const result =
     action === 'start' ? startDispatch(args, context) :
+    action === 'checkpoint' ? checkpointDispatch(args, context) :
+    action === 'status' ? statusDispatch(args, context) :
     action === 'complete' ? completeDispatch(args, context) :
     abortDispatch(args, context);
 
@@ -1987,6 +2245,33 @@ function validatorStart(args, context) {
     };
   }
 
+  const liveness = context.dispatch.active.liveness && typeof context.dispatch.active.liveness === 'object'
+    ? context.dispatch.active.liveness
+    : null;
+  const checkpoints = Array.isArray(liveness?.checkpoints) ? liveness.checkpoints : [];
+  const lastCheckpoint = checkpoints.at(-1);
+  if (
+    liveness?.status !== 'handoff_ready'
+    || liveness.last_checkpoint !== 'state_path_created'
+    || lastCheckpoint?.event !== 'state_path_created'
+    || lastCheckpoint?.state_path !== statePathValue
+  ) {
+    return {
+      gate: 'G12',
+      action: 'start',
+      status: 'blocked',
+      timestamp,
+      error: 'Validator bloqueado: executor não comprovou state_path_created para este state_path',
+      current_phase: 'plan_execute',
+      executor_liveness: liveness?.status ?? 'not_tracked',
+      expected_checkpoint: 'state_path_created',
+      state_path: statePathValue,
+      last_checkpoint: liveness?.last_checkpoint ?? null,
+      last_state_path: lastCheckpoint?.state_path ?? null,
+      next_action: 'aguardar_state_path_created_antes_do_validator',
+    };
+  }
+
   if (cycle.active) {
     return {
       gate: 'G4',
@@ -2876,7 +3161,7 @@ function toolsList() {
       },
       {
         name: 'atlas_lock_dispatch',
-        description: 'Gates G7/G8: controla fase ativa, transições de dispatch, validator antes de review e concorrência 1.',
+        description: 'Gates G7/G8/G12: controla fase ativa, checkpoints de liveness do executor, transições de dispatch, validator antes de review e concorrência 1.',
         inputSchema: {
           type: 'object',
           additionalProperties: false,
@@ -2884,8 +3169,16 @@ function toolsList() {
           properties: {
             run_id: { type: 'string', minLength: 1 },
             project_root: { type: 'string', minLength: 1 },
-            action: { type: 'string', enum: ['start', 'complete', 'abort'], default: 'start' },
+            action: { type: 'string', enum: ['start', 'checkpoint', 'status', 'complete', 'abort'], default: 'start' },
             phase: { type: 'string', enum: ['plan_handoff', 'plan_execute', 'slice_review'] },
+            event: {
+              type: 'string',
+              enum: [...EXECUTOR_CHECKPOINT_EVENTS],
+              description: 'Checkpoint G12 emitido pelo executor durante plan_execute.',
+            },
+            plan_path: { type: 'string' },
+            state_path: { type: 'string' },
+            detail: { type: 'string' },
             validator_status: { type: 'string' },
           },
         },

package/hosts/opencode/.opencode/skills/atlas-direct-execute/SKILL.md

@@ -11,6 +11,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:
@@ -40,6 +63,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:
@@ -57,6 +82,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.
@@ -122,6 +149,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:
@@ -148,6 +177,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).