atlas-workflow 0.8.2 → 0.9.0

package/hosts/pi/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.9.0.
 
 ## 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/pi/atlas/packages/mcp-server/package.json

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

package/hosts/pi/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}`;
@@ -255,6 +266,25 @@ const HOST_ADAPTERS = {
     // Fail-closed — só passam se o caller reportar disponibilidade real (não otimismo do perfil).
     prereq_policy: 'must_report',
   },
+  antigravity: {
+    label: 'Antigravity',
+    subagent_dispatch: {
+      mechanism: 'define_subagent(name, system_prompt) + invoke_subagent(Subagents)',
+      example: 'define_subagent(name: "atlas-task-validator", system_prompt: "<SKILL_MD>") e invoke_subagent(Subagents: [{TypeName: "atlas-task-validator", Role: "Validator", Prompt: "<state_path>"}])',
+      registration: 'Mapeamento de skills e agents via define_subagent dinâmico',
+    },
+    validator_dispatch: {
+      dispatcher: 'orchestrator',
+      join: {
+        sync: 'self_evident',
+        confidence: 'high',
+        mechanism: 'invoke_subagent bloqueante por design do host',
+      },
+    },
+    todo_tool: null,
+    hooks: { supported: false, mechanism: null },
+    capabilities_flags: { subagent_available: true, mcp_available: true, todo_available: false },
+  },
   generic: {
     label: 'Host genérico',
     subagent_dispatch: {
@@ -512,7 +542,15 @@ function parseWorkflowConfig() {
 
 function consumerRoot(args = {}) {
   const explicitRoot = optionalString(args, 'project_root');
-  return path.resolve(explicitRoot && explicitRoot.trim() !== '' ? explicitRoot : process.cwd());
+  if (explicitRoot && explicitRoot.trim() !== '') {
+    return path.resolve(explicitRoot);
+  }
+  const cwd = process.cwd();
+  if (cwd === '/' || cwd === '/var/folders') {
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (home) return path.resolve(home);
+  }
+  return path.resolve(cwd);
 }
 
 function runRoot(args = {}) {
@@ -584,6 +622,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;
@@ -597,8 +640,12 @@ function redact(value) {
 }
 
 function logCall(entry, args = {}) {
-  const line = JSON.stringify({ timestamp: nowIso(), ...entry }) + '\n';
-  fs.appendFileSync(path.join(ensureRunDir(args), 'mcp.log'), line, { mode: 0o600 });
+  try {
+    const line = JSON.stringify({ timestamp: nowIso(), ...entry }) + '\n';
+    fs.appendFileSync(path.join(ensureRunDir(args), 'mcp.log'), line, { mode: 0o600 });
+  } catch (error) {
+    // Ignora silenciosamente falhas de gravação de log (ex: diretório somente-leitura)
+  }
 }
 
 function rpcError(code, message, data) {
@@ -882,6 +929,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 +1741,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 +1821,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 +1834,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 +2183,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 +2276,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',
@@ -2733,11 +3049,14 @@ function assertAfterPlan(args = {}) {
 }
 
 function toolResult(value) {
+  // JSON compacto (sem indentação): o consumidor é o LLM orquestrador, que parseia
+  // igual com ou sem whitespace. Pretty-print só gastava tokens em toda resposta MCP
+  // (~10-13 por run). Mesmos campos/valores — zero impacto em determinismo/contrato.
   return {
     content: [
       {
         type: 'text',
-        text: JSON.stringify(value, null, 2),
+        text: JSON.stringify(value),
       },
     ],
   };
@@ -2876,7 +3195,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 +3203,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' },
           },
         },
@@ -3027,9 +3354,9 @@ function startStdioLoop() {
           send({
             id: message.id,
             error: {
-              code: error.code ?? -32000,
+              code: Number.isInteger(error.code) ? error.code : -32603,
               message: error.message,
-              data: error.data,
+              data: error.data || { original_code: error.code },
             },
           });
         }

package/hosts/pi/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).

package/hosts/pi/skills/atlas-plan-execute/SKILL.md

@@ -22,6 +22,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:
@@ -55,6 +78,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).
@@ -72,12 +97,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).
 
@@ -113,6 +142,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).