atlas-workflow 0.8.2

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

@@ -0,0 +1,3076 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const SERVER_NAME = 'atlas-workflow-orchestrator';
+const RUN_DIR = path.join('.atlas', 'state');
+const SENSITIVE_KEY = /(authorization|credential|password|secret|token|api[_-]?key)/i;
+// S04: chaves cujo nome casa com SENSITIVE_KEY (substring `token`) mas NÃO são
+// segredo/PII — são contadores monotônicos do slot de validação que PRECISAM
+// persistir e sobreviver a re-spun. Allowlist exata (não substring).
+// APENAS `dispatch_token` (nome interno específico); a chave genérica `token`
+// permanece sujeita a redação para não expor segredos de payloads de usuário.
+const NON_SENSITIVE_KEYS = new Set(['dispatch_token']);
+const SERVER_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PRD_PATTERNS = {
+  section_1_context: ['TBD', 'a confirmar', 'talvez', 'não definido'],
+  section_2_scope: ['pode ser', 'depende de', 'ainda não', 'incompleto'],
+  section_3_decisions: ['vago'],
+  section_4_experience: ['a definir', 'gap', 'depende de'],
+  section_5_contracts: ['ainda não definido', 'mock apenas', 'a confirmar'],
+};
+const SECTION_LABELS = {
+  section_1_context: '§1 Contexto e objetivo',
+  section_2_scope: '§2 Escopo',
+  section_3_decisions: '§3 Decisões de produto',
+  section_4_experience: '§4 Fluxos e cenários UX',
+  section_5_contracts: '§5 Contrato funcional e invariantes',
+};
+const SECTION_HEADING = {
+  section_1_context: /^##\s+1\.\s+/,
+  section_2_scope: /^##\s+2\.\s+/,
+  section_3_decisions: /^##\s+3\.\s+/,
+  section_4_experience: /^##\s+4\.\s+/,
+  section_5_contracts: /^##\s+5\.\s+/,
+};
+const REQUIRED_PRD_SECTIONS = [
+  ['1', 'Contexto e objetivo'],
+  ['2', 'Escopo'],
+  ['3', 'Decisões de produto'],
+  ['4', 'Fluxos e cenários UX'],
+  ['5', 'Contrato funcional e invariantes'],
+  ['6', 'Critérios de aceite'],
+];
+const REQUIRED_PLAN_SECTIONS = [
+  ['1', 'Tradução executiva'],
+  ['2', 'Invariantes de execução'],
+  ['3', 'Pitfalls'],
+  ['4', 'Estado na abertura da sprint'],
+  ['5', 'Tarefas de execução'],
+  ['6', 'Contratos técnicos'],
+  ['7', 'Slices'],
+  ['8', 'Validação e checklist'],
+];
+const WORKFLOW_CONFIG = {
+  path: 'builtin:atlas-workflow',
+  skills: {
+    backlog_generator: 'atlas-backlog-generator',
+    prd_generator: 'atlas-sprint-prd-generator',
+    prd_interview: 'atlas-prd-interview',
+    plan_handoff: 'atlas-plan-handoff',
+    plan_execute: 'atlas-plan-execute',
+    findings_repair: 'atlas-findings-repair',
+    slice_review: 'atlas-slice-review',
+    task_validator: 'atlas-task-validator',
+  },
+  modes: ['full', 'direct', 'execute', 'interview-only', 'interview_only'],
+};
+
+const VALIDATOR_MAX_ATTEMPTS = 2;
+// P2-1: teto de falhas de proof-of-work POR attempt. challenge_failed não consome
+// attempt nem fecha o slot (re-despacha o mesmo validador), mas sem limite um
+// mismatch sistemático (ex.: validador resolve o path do challenge com CWD
+// diferente do consumer_root do MCP) loopa pra sempre. Após este teto de falhas
+// para o mesmo validator_run_id, o slot fecha terminal (fail-closed): a slice
+// 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']);
+
+function validatorRunId(runId, attempt, timestamp) {
+  return `${runId}:validator:${attempt}:${timestamp}`;
+}
+
+function repairRunId(runId, attempt, timestamp) {
+  return `${runId}:repair:${attempt}:${timestamp}`;
+}
+
+// Nível de garantia declarado no routing/output (PRD D12). Enum fechado:
+// pipelines completas (full/direct/execute) declaram full_pipeline; uso avulso
+// documental/leitura declara reduced_standalone (fora do escopo desta camada).
+// Data-driven: rota → nível, sem ramo solto. Modos sem execução de código
+// (interview-only) NÃO declaram guarantee_level (não há execução a garantir):
+// guaranteeLevelForMode devolve null e o campo é OMITIDO do output (PRD D2/D12).
+const GUARANTEE_LEVELS = ['full_pipeline', 'reduced_standalone'];
+const MODE_GUARANTEE_LEVEL = {
+  full: 'full_pipeline',
+  direct: 'full_pipeline',
+  execute: 'full_pipeline',
+};
+function guaranteeLevelForMode(mode) {
+  return MODE_GUARANTEE_LEVEL[mode] ?? null;
+}
+
+// Banco canônico de templates de banner de fase (PRD §4 Fluxos / D*, PLAN §6.2).
+// Fonte única na camada determinística: o orquestrador apenas ECOA a string
+// pronta — nunca monta texto livre. Data-driven como HOST_ADAPTERS: tabela única
+// `event → template`, sem string de banner inline espalhada pelos gates.
+// Símbolo fixo `▸`, idioma pt-BR, exatamente uma linha por evento. Os 11 eventos
+// fechados do PRD §4. Slots no formato {nome} são preenchidos por renderBanner.
+const BANNER_TEMPLATES = {
+  roteia: '▸ atlas: roteamento · input={tipo} → modo={modo}',
+  roteia_troca: '▸ atlas: roteamento · pediu={x} mas input={y} → modo={z}',
+  preflight_ok: '▸ atlas: preflight · ok ({caps})',
+  preflight_fail: '▸ atlas: preflight · BLOCK · {motivo}',
+  prd_lacunas: '▸ atlas: prd · {n} lacunas',
+  prd_ok: '▸ atlas: prd · ok',
+  entrevista: '▸ atlas: entrevista · {n} perguntas',
+  plano: '▸ atlas: plano · validado (TC pass)',
+  exec: '▸ atlas: exec · slice {i}/{n}',
+  validacao: '▸ atlas: validação · {status}',
+  review: '▸ atlas: review · {status}',
+  done: '▸ atlas: done · {resumo}',
+};
+const BANNER_EVENTS = Object.keys(BANNER_TEMPLATES);
+
+// Modo-alvo do roteamento por tipo de input (PRD D3/D6): o tipo de fato manda
+// sobre o modo pedido. plan → execute (executa plano pronto); prd/backlog → full
+// (gera/usa plano). Data-driven: alimenta o slot {modo} do banner `roteia`.
+const ROUTED_MODE_BY_TYPE = {
+  plan: 'execute',
+  prd: 'full',
+  backlog: 'full',
+  // idea = descrição livre (não é arquivo). Roteia para `direct` (implementa a partir da
+  // descrição/spec, sem artefato de plano separado). Não é "input ilegível".
+  idea: 'direct',
+};
+
+// Preenche os slots {nome} do template do evento com `slots` e devolve a string
+// pt-BR pronta. Evento desconhecido é erro de programação (lança). Slot ausente
+// não é silenciado: deixa o marcador visível para o defeito não passar batido.
+function renderBanner(event, slots = {}) {
+  const template = BANNER_TEMPLATES[event];
+  if (template === undefined) {
+    throw rpcError(-32603, `Evento de banner desconhecido: ${event}`);
+  }
+  return template.replace(/\{(\w+)\}/g, (match, key) => (
+    Object.prototype.hasOwnProperty.call(slots, key) ? String(slots[key]) : match
+  ));
+}
+// Camada de adapter: conhecimento host-específico centralizado em código.
+// Skills consultam atlas_capabilities e usam o descritor retornado em vez de
+// hardcodar nome de host. Adicionar host novo = adicionar entrada aqui.
+// Contrato HostAdapter (DEC-007): entrada runtime data-driven. Campos:
+//   subagent_dispatch, todo_tool, hooks, capabilities_flags. plan_paths/state são
+//   portáveis (iguais a todos os hosts) e vivem em capabilities(). Adicionar host =
+//   adicionar entrada aqui; nenhum ramo `if host==` em outro lugar.
+// capabilities_flags: pré-requisitos essenciais (subagent_available, mcp_available)
+//   são hard-fail no preflight (DEC-004); todo_available é não-essencial.
+const HOST_ADAPTERS = {
+  claude: {
+    label: 'Claude Code',
+    subagent_dispatch: {
+      mechanism: 'Agent(subagent_type)',
+      example: 'Agent(subagent_type: "atlas-task-validator", prompt: "<state_path>")',
+      registration: 'agents/<name>.md na raiz do plugin',
+    },
+    validator_dispatch: {
+      dispatcher: 'orchestrator',
+      join: {
+        sync: 'self_evident',
+        confidence: 'presumed',
+        mechanism: 'Agent(subagent_type) bloqueante por design do host',
+      },
+    },
+    todo_tool: 'TodoWrite',
+    hooks: { supported: true, mechanism: 'hooks/claude/settings.snippet.json' },
+    capabilities_flags: { subagent_available: true, mcp_available: true, todo_available: true },
+  },
+  codex: {
+    label: 'Codex App',
+    subagent_dispatch: {
+      mechanism: 'spawn_agent(agent_type)',
+      example: 'spawn_agent(agent_type: "atlas-task-validator", items: [{ type: "text", text: "<state_path>" }])',
+      registration: 'CODEX_HOME/agents/<name>.toml via `npx github:pauloborini/atlas-workflow init codex` (custom agent nativo; developer_instructions carrega o SKILL.md; atlas-task-validator pinado em model=gpt-5.4, model_reasoning_effort=high)',
+    },
+    validator_dispatch: {
+      dispatcher: 'orchestrator',
+      required_agent_type: 'atlas-task-validator',
+      required_codex_model: 'gpt-5.4',
+      required_codex_model_reasoning_effort: 'high',
+      join: {
+        sync: 'self_evident',
+        confidence: 'confirmed',
+        mechanism: 'spawn_agent bloqueante; retorno via state_path + veredito; no Codex deve usar explicitamente agent_type="atlas-task-validator"',
+      },
+    },
+    todo_tool: 'tasks',
+    hooks: { supported: false, mechanism: null },
+    // Codex subagents are native, but spawned agents do not receive spawn_agent in
+    // the current host tool surface. Validator runs as an isolated sibling
+    // dispatched by the orchestrator after the executor writes state_path.
+    capabilities_flags: { subagent_available: true, mcp_available: true, todo_available: true },
+  },
+  opencode: {
+    label: 'opencode',
+    subagent_dispatch: {
+      mechanism: '@<name> (ou auto por description)',
+      example: 'invocar @atlas-task-validator passando <state_path>',
+      registration: '.opencode/agents/<name>.md (frontmatter description + mode: subagent)',
+    },
+    validator_dispatch: {
+      dispatcher: 'orchestrator',
+      join: {
+        sync: 'self_evident',
+        confidence: 'presumed',
+        mechanism: '@<name> bloqueante presumido',
+      },
+    },
+    // opencode expõe `todowrite` nativo ao agente primário (orquestrador). O `todoread`
+    // foi fundido em `todowrite` (mar/2026): a tool retorna a lista atual no output.
+    // Subagentes têm `todowrite` desabilitado por padrão, mas o todo é usado pelo
+    // orquestrador (primário), não pelos validadores — então a flag descreve o nível certo.
+    todo_tool: 'todowrite',
+    hooks: { supported: true, mechanism: '.opencode/plugins/' },
+    // Nativo compatível: subagente (.opencode/agents) + MCP local (opencode.json) + todo (todowrite).
+    capabilities_flags: { subagent_available: true, mcp_available: true, todo_available: true },
+  },
+  pi: {
+    label: 'pi cli',
+    subagent_dispatch: {
+      // pi-subagents dispara pela tool `subagent({agent, task})` — NÃO por @name nem via MCP.
+      // As tools MCP do Atlas chegam proxiadas/prefixadas pelo pi-mcp-adapter (atlas_workflow_<tool>).
+      mechanism: 'subagent({ agent, task }) — tool do pi-subagents',
+      example: 'subagent({ agent: "atlas-task-validator", task: "<state_path>", context: "fresh" })',
+      registration: '.pi/agents/<name>.md (pi-subagents; frontmatter name + description + tools)',
+    },
+    validator_dispatch: {
+      dispatcher: 'orchestrator',
+      join: {
+        sync: 'must_report',
+        confidence: 'reported_required',
+        mechanism: 'subagent({agent,task}) via pi-subagents; join depende de dep externa',
+      },
+    },
+    todo_tool: null,
+    hooks: { supported: false, mechanism: null },
+    // pi exige 2 deps externas obrigatórias (DEC-005): pi-mcp-adapter (MCP) e
+    // pi-subagents (subagente). O perfil declara a expectativa; a disponibilidade
+    // real é reportada em host_capabilities no preflight — ausente => hard-fail.
+    capabilities_flags: { subagent_available: true, mcp_available: true, todo_available: false },
+    required_deps: ['pi-mcp-adapter', 'pi-subagents'],
+    // must_report: essenciais dependem de deps externas não-sondáveis pelo servidor.
+    // Fail-closed — só passam se o caller reportar disponibilidade real (não otimismo do perfil).
+    prereq_policy: 'must_report',
+  },
+  generic: {
+    label: 'Host genérico',
+    subagent_dispatch: {
+      mechanism: 'subagente nativo do host',
+      example: 'despachar o subagente atlas-task-validator passando apenas <state_path>',
+      registration: 'mecanismo nativo equivalente do host',
+    },
+    validator_dispatch: {
+      dispatcher: 'orchestrator',
+      join: {
+        sync: 'must_report',
+        confidence: 'reported_required',
+        mechanism: 'indeterminado; host deve reportar',
+      },
+    },
+    todo_tool: null,
+    hooks: { supported: false, mechanism: null },
+    // generic EXIGE subagente+MCP do host (DEC-004); host MCP-only sem subagente
+    // fica fora de escopo e é rejeitado no preflight, não degradado.
+    capabilities_flags: { subagent_available: true, mcp_available: true, todo_available: false },
+    // must_report: host desconhecido — o servidor não pode presumir subagente+MCP.
+    // Fail-closed — exige report afirmativo de disponibilidade.
+    prereq_policy: 'must_report',
+  },
+};
+
+// Pré-requisitos de determinismo (DEC-004): essenciais → hard-fail no preflight;
+// não-essenciais → seguem sem o recurso, registrando. Contrato consumido por S09.
+const PREREQUISITES = {
+  essential: ['subagent_available', 'mcp_available'],
+  non_essential: ['todo_available'],
+};
+const PREREQUISITE_FLAGS = [...PREREQUISITES.essential, ...PREREQUISITES.non_essential];
+
+// Versão do contrato atlas_capabilities. Política: incremento aditivo (campos novos
+// opcionais) mantém compat — consumidores DEVEM ignorar campos desconhecidos.
+// Remoção/renomeação de campo ou mudança de semântica exige bump e nota de migração.
+// v1 → v2: adiciona capabilities_flags, hooks, prerequisites, known_hosts,
+//   required_deps, prereq_policy (aditivo).
+// v2 → v3: adiciona validator_dispatch (quem despacha o validador frio G4 e como).
+// v3 → v4 (DEC-SIB-001/003): sibling é a única topologia. validator_dispatch
+//   colapsa para `{ dispatcher: 'orchestrator' }` em todos os hosts; os campos de
+//   topologia legada (dispatcher por executor) foram REMOVIDOS do contrato
+//   (mudança de semântica → bump consciente). Consumidores que liam o antigo
+//   validator_dispatch.topology devem assumir sibling incondicionalmente. Estado antigo em disco com esses
+//   campos é rollback-safe: campos extras são ignorados pelo spread/normalize.
+// v4 → v5 (DEC-SIB-003, S06, SPEC_JOIN_CAPABILITY_S03 §2.2): adiciona
+//   validator_dispatch.join { sync, confidence, mechanism } por host. Aditivo
+//   (campo novo; nenhum campo removido nesta etapa). O input do preflight ganha
+//   host_capabilities.join_sync_available (opcional, gate JOIN separado — NÃO é
+//   flag de prereq). Consumidores que ignoram campos desconhecidos seguem compatíveis.
+const CAPABILITIES_SCHEMA_VERSION = 5;
+
+// Nomes de host derivados do registry — única fonte de verdade para enums de schema.
+// Adicionar host em HOST_ADAPTERS propaga automaticamente (sem enum hardcoded).
+const HOST_NAMES = Object.keys(HOST_ADAPTERS);
+
+// Registry de detecção de host, data-driven e ordenado por precedência (DEC-003).
+// Adicionar host = adicionar um detector aqui (env próprio/arquivo); sem ramo solto.
+// `arg host` e `ATLAS_HOST` (override explícito) têm prioridade sobre sinais de env.
+// Cada detector retorna o nome do host se casar, ou null. Só hosts presentes em
+// HOST_ADAPTERS são aceitos (perfil desconhecido cai em generic).
+const HOST_DETECTORS = [
+  { via: 'env:CLAUDE_PLUGIN_ROOT', detect: (env) => (env.CLAUDE_PLUGIN_ROOT ? 'claude' : null) },
+  { via: 'env:CODEX', detect: (env) => (env.CODEX_HOME || env.CODEX_PLUGIN_ROOT ? 'codex' : null) },
+  // opencode/pi não expõem env distintivo garantido no subprocesso MCP (S01).
+  // Detecção determinística: o packaging injeta ATLAS_HOST no env do MCP —
+  //   opencode: opencode.json → mcp.<name>.environment.ATLAS_HOST = "opencode"
+  //   pi: mcp.json (pi-mcp-adapter) → env.ATLAS_HOST = "pi"
+  // Tratado pela branch ATLAS_HOST acima; sem file-detection frágil.
+];
+
+function detectHost(args = {}, env = process.env) {
+  if (args.host && HOST_ADAPTERS[args.host]) return { host: args.host, detected_via: 'arg' };
+  const override = env.ATLAS_HOST;
+  if (override && HOST_ADAPTERS[override]) return { host: override, detected_via: 'env:ATLAS_HOST' };
+  for (const detector of HOST_DETECTORS) {
+    const host = detector.detect(env);
+    if (host && HOST_ADAPTERS[host]) return { host, detected_via: detector.via };
+  }
+  return { host: 'generic', detected_via: 'default' };
+}
+
+function capabilities(args = {}) {
+  const { host, detected_via } = detectHost(args);
+  const adapter = HOST_ADAPTERS[host];
+  return {
+    host,
+    host_label: adapter.label,
+    detected_via,
+    schema_version: CAPABILITIES_SCHEMA_VERSION,
+    subagent_dispatch: adapter.subagent_dispatch,
+    validator_dispatch: adapter.validator_dispatch,
+    todo_tool: adapter.todo_tool,
+    hooks: adapter.hooks,
+    capabilities_flags: adapter.capabilities_flags,
+    required_deps: adapter.required_deps ?? [],
+    prerequisites: PREREQUISITES,
+    // 'must_report' avisa o orquestrador que DEVE apurar e reportar host_capabilities
+    // (subagente/MCP reais) no preflight — sem isso, o gate PREREQ falha-fechado.
+    prereq_policy: adapter.prereq_policy ?? 'self_evident',
+    plan_paths: {
+      write: '.atlas/plans/',
+      read_order: ['.atlas/plans/', '.cursor/plans/', '.codex/plans/'],
+      deprecated_read: ['.cursor/plans/', '.codex/plans/'],
+    },
+    state_backend: 'atlas_run_state',
+    state_dir: RUN_DIR,
+    known_hosts: Object.keys(HOST_ADAPTERS),
+  };
+}
+
+// Hard-fail de pré-requisitos de determinismo (DEC-004). Mescla as flags do perfil
+// do host com a disponibilidade real reportada pelo caller (`host_capabilities`).
+//
+// Política por host (`prereq_policy`):
+//   - 'self_evident' (claude/codex/opencode, default): runtime nativo. Flag essencial
+//     vem do report quando presente, senão do perfil (otimista justificado: MCP-vivo
+//     prova-se no boot; subagente é nativo do host/plugin instalado).
+//   - 'must_report' (pi/generic): essencial depende de dep externa (pi) ou de host
+//     desconhecido (generic) — NÃO sondável pelo servidor. Fail-closed: a flag só
+//     conta como true se reportada explicitamente true; ausente/não-bool ⇒ false ⇒
+//     blocked. Converte a garantia de prosa do orquestrador em contrato.
+//
+// O merge é delimitado a PREREQUISITE_FLAGS (chave desconhecida no override é ignorada;
+// o additionalProperties:false do schema é enforçado na camada do client MCP, este
+// loop é a defesa server-side). Capability não-essencial (todo) nunca bloqueia.
+function checkPrerequisites(args = {}) {
+  const { host } = detectHost(args);
+  const adapter = HOST_ADAPTERS[host];
+  const mustReport = adapter.prereq_policy === 'must_report';
+  const reported = args.host_capabilities && typeof args.host_capabilities === 'object'
+    ? args.host_capabilities
+    : {};
+  const flags = {};
+  for (const key of PREREQUISITE_FLAGS) {
+    const reportedVal = typeof reported[key] === 'boolean' ? reported[key] : undefined;
+    if (mustReport && PREREQUISITES.essential.includes(key)) {
+      flags[key] = reportedVal === true;
+    } else {
+      flags[key] = reportedVal !== undefined ? reportedVal : adapter.capabilities_flags[key];
+    }
+  }
+  const missing = PREREQUISITES.essential.filter((key) => flags[key] !== true);
+  if (missing.length === 0) {
+    return { status: 'passed', host, effective_flags: flags, missing: [] };
+  }
+  const unreported = mustReport && PREREQUISITES.essential.every(
+    (key) => typeof reported[key] !== 'boolean',
+  );
+  return {
+    status: 'blocked',
+    host,
+    effective_flags: flags,
+    missing,
+    error: `Pré-requisito de determinismo ausente no host '${host}': ${missing.join(', ')}`,
+    cause: unreported ? 'host_nao_reportou_disponibilidade' : 'host_sem_prerequisito_essencial',
+    impact: 'sem_isolamento_de_contexto_o_validator_perde_determinismo_em_tarefa_grande',
+    next_action: host === 'pi'
+      ? 'instalar_pi-mcp-adapter_e_pi-subagents_e_reportar_host_capabilities'
+      : 'usar_host_com_subagente_e_mcp_nativos_ou_reportar_host_capabilities',
+  };
+}
+
+// Gate JOIN (DEC-SIB-003, SPEC_JOIN_CAPABILITY_S03 §3/§5). Espelha checkPrerequisites:
+// lê validator_dispatch.join do adapter e decide hard-fail por política.
+//   - join.sync === 'self_evident' (claude/codex/opencode): host nativo conhecido;
+//     o runtime presume join disponível e NÃO exige report. confidence 'presumed'
+//     (claude/opencode) passa, mas é registrado para observabilidade (smoke S13).
+//   - join.sync === 'must_report' (pi/generic): fail-closed. Só passa se o caller
+//     reportar host_capabilities.join_sync_available === true. Ausente/não-bool ⇒ blocked.
+// join_sync_available é gate SEPARADO — não entra em PREREQUISITE_FLAGS nem polui
+// effective_flags de checkPrerequisites (o merge daquele loop ignora chaves desconhecidas).
+function checkJoinCapability(args = {}) {
+  const { host } = detectHost(args);
+  const adapter = HOST_ADAPTERS[host];
+  const join = adapter.validator_dispatch?.join ?? {};
+  const reported = args.host_capabilities && typeof args.host_capabilities === 'object'
+    ? args.host_capabilities
+    : {};
+  if (join.sync === 'must_report') {
+    if (reported.join_sync_available === true) {
+      return { status: 'passed', host, confidence: join.confidence };
+    }
+    return {
+      status: 'blocked',
+      host,
+      error: `host '${host}' não reportou join síncrono; sibling exige join (DEC-SIB-003)`,
+      cause: 'host_nao_reportou_join_sincrono',
+      impact: 'sem_join_sincrono_o_slot_de_validacao_vaza_em_fire_and_forget',
+      next_action: 'instalar_deps_de_subagente_sincrono_ou_usar_host_nativo_e_reportar_join_sync_available',
+    };
+  }
+  // self_evident: passa sem report (host nativo). confidence preservado p/ observabilidade.
+  return { status: 'passed', host, confidence: join.confidence };
+}
+
+const LEGACY_ROUTE_KEY = ['fam', 'ily'].join('');
+const VERSION_CANDIDATES = [
+  path.resolve(SERVER_DIR, '../../VERSION'),
+];
+const PACKAGE_VERSION_CANDIDATES = [
+  path.resolve(SERVER_DIR, 'package.json'),
+];
+
+function readVersion() {
+  const info = readVersionInfo();
+  return info.version;
+}
+
+function readVersionInfo() {
+  let rootVersion = null;
+  let packageVersion = null;
+  const errors = [];
+
+  for (const candidate of VERSION_CANDIDATES) {
+    try {
+      if (!fs.existsSync(candidate)) continue;
+      const value = fs.readFileSync(candidate, 'utf8').trim();
+      if (value) {
+        rootVersion = value;
+        break;
+      }
+    } catch (error) {
+      errors.push({ path: candidate, cause: error.message });
+    }
+  }
+
+  for (const candidate of PACKAGE_VERSION_CANDIDATES) {
+    try {
+      if (!fs.existsSync(candidate)) continue;
+      packageVersion = JSON.parse(fs.readFileSync(candidate, 'utf8')).version || null;
+      if (packageVersion) break;
+    } catch (error) {
+      errors.push({ path: candidate, cause: error.message });
+    }
+  }
+
+  const version = rootVersion || packageVersion || 'unknown';
+  const mismatch = rootVersion && packageVersion && rootVersion !== packageVersion;
+  return {
+    version,
+    root_version: rootVersion,
+    package_version: packageVersion,
+    status: mismatch ? 'blocked' : 'passed',
+    error: mismatch ? `Drift de versão: VERSION=${rootVersion}, package.json=${packageVersion}` : null,
+    errors,
+    next_action: mismatch ? 'alinhar_versoes_do_plugin' : 'avançar',
+  };
+}
+
+function parseWorkflowConfig() {
+  return WORKFLOW_CONFIG;
+}
+
+function consumerRoot(args = {}) {
+  const explicitRoot = optionalString(args, 'project_root');
+  return path.resolve(explicitRoot && explicitRoot.trim() !== '' ? explicitRoot : process.cwd());
+}
+
+function runRoot(args = {}) {
+  return path.join(consumerRoot(args), RUN_DIR);
+}
+
+function ensureRunDir(args = {}) {
+  const dir = runRoot(args);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  return dir;
+}
+
+function validateRunId(runId) {
+  if (typeof runId !== 'string' || runId.trim() === '') {
+    throw rpcError(-32602, 'run_id obrigatório');
+  }
+  if (!/^[A-Za-z0-9._-]+$/.test(runId)) {
+    throw rpcError(-32602, 'run_id inválido: use apenas letras, números, ponto, hífen ou underscore');
+  }
+  return runId;
+}
+
+function optionalString(args, key) {
+  const value = args[key];
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== 'string') {
+    throw rpcError(-32602, `Campo inválido: ${key} deve ser string`);
+  }
+  return value;
+}
+
+function optionalData(args) {
+  if (args.data === undefined || args.data === null) return undefined;
+  if (typeof args.data !== 'object' || Array.isArray(args.data)) {
+    throw rpcError(-32602, 'Campo inválido: data deve ser objeto');
+  }
+  return args.data;
+}
+
+function requiredString(args, key) {
+  const value = optionalString(args, key);
+  if (!value || value.trim() === '') {
+    throw rpcError(-32602, `${key} obrigatório`);
+  }
+  return value;
+}
+
+function optionalInteger(args, key) {
+  const value = args[key];
+  if (value === undefined || value === null) return undefined;
+  if (!Number.isInteger(value)) {
+    throw rpcError(-32602, `Campo inválido: ${key} deve ser inteiro`);
+  }
+  return value;
+}
+
+function resolveConsumerPath(inputPath, args = {}) {
+  const value = requiredString({ value: inputPath }, 'value');
+  return path.resolve(consumerRoot(args), value);
+}
+
+function statePath(runId, args = {}) {
+  const runDir = path.join(ensureRunDir(args), validateRunId(runId));
+  fs.mkdirSync(runDir, { recursive: true, mode: 0o700 });
+  return path.join(runDir, 'run.json');
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function redact(value) {
+  if (Array.isArray(value)) return value.map(redact);
+  if (!value || typeof value !== 'object') return value;
+
+  return Object.fromEntries(
+    Object.entries(value).map(([key, nested]) => [
+      key,
+      SENSITIVE_KEY.test(key) && !NON_SENSITIVE_KEYS.has(key) ? '[REDACTED]' : redact(nested),
+    ]),
+  );
+}
+
+function logCall(entry, args = {}) {
+  const line = JSON.stringify({ timestamp: nowIso(), ...entry }) + '\n';
+  fs.appendFileSync(path.join(ensureRunDir(args), 'mcp.log'), line, { mode: 0o600 });
+}
+
+function rpcError(code, message, data) {
+  const error = new Error(message);
+  error.code = code;
+  error.data = data;
+  return error;
+}
+
+function ping() {
+  const version = readVersionInfo();
+  return {
+    status: version.status === 'passed' ? 'alive' : 'blocked',
+    name: SERVER_NAME,
+    version: version.version,
+    version_check: version,
+    transport: 'stdio',
+    // Fonte única da superfície de tools: derivado de toolsList() para nunca
+    // divergir do dispatcher/schema. Lista manual paralela já omitiu
+    // atlas_classify_input no passado (drift silencioso) — o orquestrador
+    // (Fase 0) aborta se uma capability exigida pelo modo não aparece aqui,
+    // então a divergência travava run válida. Guard cruzado em server.test.js.
+    capabilities: toolsList().tools.map((tool) => tool.name),
+    state_dir: RUN_DIR,
+  };
+}
+
+function stateInvalid(message, cause, extra = {}) {
+  return {
+    status: 'blocked',
+    error: message,
+    cause,
+    impact: 'ledger_nao_confiavel_fase_bloqueada',
+    next_action: 'recuperar_ou_remover_estado_invalido_com_decisao_explicita',
+    ...extra,
+  };
+}
+
+function validateStateShape(state, source) {
+  if (!state || typeof state !== 'object' || Array.isArray(state)) {
+    return stateInvalid(`Estado local incompatível: ${source}`, 'state_nao_e_objeto');
+  }
+  if (typeof state.run_id !== 'string' || state.run_id.trim() === '') {
+    return stateInvalid(`Estado local parcial: ${source}`, 'run_id_ausente_ou_invalido');
+  }
+  if (typeof state.phase !== 'string' || state.phase.trim() === '') {
+    return stateInvalid(`Estado local parcial: ${source}`, 'phase_ausente_ou_invalida', { run_id: state.run_id });
+  }
+  if (typeof state.status !== 'string' || state.status.trim() === '') {
+    return stateInvalid(`Estado local parcial: ${source}`, 'status_ausente_ou_invalido', { run_id: state.run_id });
+  }
+  if (!state.data || typeof state.data !== 'object' || Array.isArray(state.data)) {
+    return stateInvalid(`Estado local parcial: ${source}`, 'data_ausente_ou_invalida', { run_id: state.run_id });
+  }
+  const stateVersion = state.data?.routing?.version;
+  const currentVersion = readVersionInfo().version;
+  if (stateVersion && stateVersion !== currentVersion) {
+    return stateInvalid(
+      `Estado local incompatível: ${source}`,
+      `routing.version=${stateVersion}, current=${currentVersion}`,
+      {
+        run_id: state.run_id,
+        impact: 'pipeline_hibrido_poderia_gerar_ledger_falso',
+        next_action: 'reiniciar_run_apos_alinhar_versao_do_plugin',
+      },
+    );
+  }
+  return { status: 'passed', state };
+}
+
+function inspectRunStateFile(file) {
+  try {
+    const state = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return validateStateShape(state, path.basename(file));
+  } catch (error) {
+    return stateInvalid(
+      `Estado local corrompido: ${file}`,
+      error.message,
+      { next_action: 'recuperar_ou_remover_estado_corrompido_com_decisao_explicita' },
+    );
+  }
+}
+
+function findActiveRunConflict(runId, args = {}) {
+  const dir = ensureRunDir(args);
+  for (const name of fs.readdirSync(dir)) {
+    const file = path.join(dir, name, 'run.json');
+    if (!fs.existsSync(file)) continue;
+    // Atualização-simples: um run ANTIGO inativo (inclusive de versão anterior do
+    // plugin) não pode travar um run NOVO. A varredura de conflito só importa pra
+    // runs de OUTRO run_id que estejam com dispatch ATIVO. Por isso parseamos de
+    // forma tolerante e ignoramos runs inativos/corrompidos/de versão velha — a
+    // validação estrita de versão/shape do PRÓPRIO run continua em readState
+    // (validateStateShape) no caminho que de fato opera sobre aquele estado.
+    let state;
+    try {
+      state = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      continue; // run alheio corrompido não é nosso conflito
+    }
+    if (!state || typeof state !== 'object' || state.run_id === runId) continue;
+    const active = state.data?.dispatch?.active;
+    if (active?.phase) {
+      // Conflito real só quando o OUTRO run ativo é da versão atual; um run ativo
+      // de versão antiga é resíduo de processo morto, não lock vivo.
+      const stateVersion = state.data?.routing?.version;
+      const currentVersion = readVersionInfo().version;
+      if (stateVersion && stateVersion !== currentVersion) continue;
+      return {
+        status: 'blocked',
+        error: `Lock conflict: run ativa ${state.run_id} na fase ${active.phase}`,
+        cause: 'dispatch_ativo_em_outra_run',
+        impact: 'segunda_run_poderia_corromper_estado_ou_ledger',
+        conflicting_run_id: state.run_id,
+        active_phase: active.phase,
+        next_action: 'aguardar_ou_liberar_lock_com_decisao_explicita',
+      };
+    }
+  }
+  return { status: 'passed' };
+}
+
+function readState(runId, args = {}) {
+  const file = statePath(runId, args);
+  if (!fs.existsSync(file)) {
+    throw rpcError(-32004, `Run inexistente: ${runId}`, { run_id: runId });
+  }
+  try {
+    const state = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const inspected = validateStateShape(state, `${runId}.json`);
+    if (inspected.status === 'blocked') {
+      throw rpcError(-32003, `Estado inválido para run: ${runId}`, {
+        run_id: runId,
+        cause: inspected.cause,
+        impact: inspected.impact,
+        next_action: inspected.next_action,
+      });
+    }
+    return state;
+  } catch (cause) {
+    if (cause.code) throw cause;
+    throw rpcError(-32003, `Estado inválido para run: ${runId}`, {
+      run_id: runId,
+      cause: cause.message,
+      impact: 'ledger_nao_confiavel_fase_bloqueada',
+      next_action: 'recuperar_ou_remover_estado_corrompido_com_decisao_explicita',
+    });
+  }
+}
+
+function upsertState(args) {
+  const runId = validateRunId(args.run_id);
+  const phase = optionalString(args, 'phase');
+  const status = optionalString(args, 'status');
+  const summary = optionalString(args, 'summary');
+  const data = optionalData(args);
+  const timestamp = nowIso();
+  let previous = null;
+
+  try {
+    previous = readState(runId, args);
+  } catch (error) {
+    if (error.code !== -32004) throw error;
+  }
+
+  const next = {
+    run_id: runId,
+    phase: phase ?? previous?.phase ?? 'unknown',
+    status: status ?? previous?.status ?? 'unknown',
+    summary: summary ?? previous?.summary ?? null,
+    // P2/S22: upsert parcial DEVE preservar chaves irmãs do estado (dispatch,
+    // validator_cycle, routing, gates). O executor escreve o handoff via
+    // atlas_run_state(upsert) com um `data` parcial; um replace cego apagava
+    // `data.dispatch.active={plan_execute}`, fazendo o lock_validator(start)
+    // seguinte bloquear ("current_phase null"). Merge top-level: o caller adiciona
+    // chaves novas sem derrubar as existentes. Sem `data` no payload → mantém o
+    // estado anterior intacto (comportamento de no-op preservado).
+    data: redact(data !== undefined ? { ...(previous?.data ?? {}), ...data } : (previous?.data ?? {})),
+    created_at: previous?.created_at ?? timestamp,
+    updated_at: timestamp,
+    last_call: {
+      tool: 'atlas_run_state',
+      action: 'upsert',
+      timestamp,
+    },
+  };
+
+  const target = statePath(runId, args);
+  const tmp = `${target}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n', { mode: 0o600 });
+  fs.renameSync(tmp, target);
+  return next;
+}
+
+function patchGateResult(runId, gate, result, args = {}) {
+  let previous = null;
+  try {
+    previous = readState(runId, args);
+  } catch (error) {
+    if (error.code !== -32004) throw error;
+  }
+
+  const data = {
+    ...(previous?.data ?? {}),
+    gates: {
+      ...(previous?.data?.gates ?? {}),
+      [gate]: redact(result),
+    },
+  };
+
+  return upsertState({
+    run_id: runId,
+    project_root: args.project_root,
+    phase: previous?.phase ?? 'gates',
+    status: result.status === 'passed' ? 'gate_passed' : 'gate_blocked',
+    summary: `${gate}: ${result.status}`,
+    data,
+  });
+}
+
+function patchTemplateConformanceResult(runId, result, args = {}) {
+  let previous = null;
+  try {
+    previous = readState(runId, args);
+  } catch (error) {
+    if (error.code !== -32004) throw error;
+  }
+
+  const data = {
+    ...(previous?.data ?? {}),
+    template_conformance: redact(result),
+    gates: {
+      ...(previous?.data?.gates ?? {}),
+      template_conformance: redact(result),
+    },
+  };
+
+  return upsertState({
+    run_id: runId,
+    project_root: args.project_root,
+    phase: previous?.phase ?? 'template_conformance',
+    status: result.status === 'passed' ? 'template_conformance_passed' : 'template_conformance_blocked',
+    summary: `template_conformance: ${result.status}`,
+    data,
+  });
+}
+
+function patchRoutingResult(runId, result, args = {}) {
+  let previous = null;
+  try {
+    previous = readState(runId, args);
+  } catch (error) {
+    if (error.code !== -32004) throw error;
+  }
+
+  const data = {
+    ...(previous?.data ?? {}),
+    routing: result.routing ?? previous?.data?.routing ?? null,
+    gates: {
+      ...(previous?.data?.gates ?? {}),
+      [result.gate ?? 'G10']: redact(result),
+    },
+  };
+
+  return upsertState({
+    run_id: runId,
+    project_root: args.project_root,
+    phase: previous?.phase ?? 'preflight',
+    status: result.status === 'passed' ? 'preflight_passed' : 'preflight_blocked',
+    summary: `G10: ${result.status}`,
+    data,
+  });
+}
+
+function patchDispatchResult(runId, result, args = {}) {
+  const previous = readState(runId, args);
+  const currentDispatch = previous.data?.dispatch ?? {};
+  const history = [
+    ...(currentDispatch.history ?? []),
+    {
+      timestamp: result.timestamp,
+      phase: result.phase ?? null,
+      action: result.action ?? null,
+      status: result.status,
+      next_action: result.next_action ?? null,
+      error: result.error ?? null,
+    },
+  ];
+  const data = {
+    ...(previous.data ?? {}),
+    dispatch: {
+      ...currentDispatch,
+      ...(result.dispatch ?? {}),
+      history,
+    },
+    gates: {
+      ...(previous.data?.gates ?? {}),
+      [result.gate ?? 'G7']: redact(result),
+    },
+  };
+
+  return upsertState({
+    run_id: runId,
+    project_root: args.project_root,
+    phase: previous.phase ?? 'dispatch',
+    status: result.status === 'passed' ? 'dispatch_ok' : 'dispatch_blocked',
+    summary: `${result.gate ?? 'G7'}: ${result.status}`,
+    data,
+  });
+}
+
+function normalizeValidatorCycle(cycle = {}) {
+  return {
+    // S04: token de dispatch monotônico explícito do slot de validação. Inteiro,
+    // sempre crescente, nunca reusado; persiste no run.json e sobrevive a re-spun.
+    dispatch_token: Number.isInteger(cycle.dispatch_token) ? cycle.dispatch_token : 0,
+    // DEC-SIB-002: o teto de attempts é invariante de CONTRATO (enforcement por
+    // tool MCP, não por estado/prosa). VALIDATOR_MAX_ATTEMPTS é o teto canônico e
+    // NÃO é configurável via estado persistido. Um run.json adulterado/corrompido
+    // com max_attempts inflado (ex.: 99) não pode elevar o teto e liberar um 3º+
+    // validator. Por isso clampamos max_attempts: inteiro válido e ≥1 vira
+    // min(estado, teto); qualquer 0/negativo/ausente/não-inteiro cai no default
+    // canônico. O valor efetivo nunca excede VALIDATOR_MAX_ATTEMPTS, e como todos
+    // os fluxos (start/complete/fail) leem o cycle por esta normalização, os
+    // retornos que ecoam cycle.max_attempts já recebem o valor clampado.
+    // Pela mesma razão, attempts_used recebe piso ≥0: um valor negativo adulterado
+    // (ex.: -5) inflaria o teto efetivo (max_attempts - attempts_used) e permitiria
+    // dispatches além do limite. Valor float/string/null cai em 0. Teto superior
+    // NÃO é necessário — attempts_used=99 já cai no lado seguro (99>=2 → blocked).
+    max_attempts: Number.isInteger(cycle.max_attempts) && cycle.max_attempts >= 1
+      ? Math.min(cycle.max_attempts, VALIDATOR_MAX_ATTEMPTS)
+      : VALIDATOR_MAX_ATTEMPTS,
+    attempts_used: Number.isInteger(cycle.attempts_used) && cycle.attempts_used >= 0
+      ? cycle.attempts_used
+      : 0,
+    status: typeof cycle.status === 'string' ? cycle.status : 'idle',
+    active: cycle.active && typeof cycle.active === 'object' ? cycle.active : null,
+    last_state_path: typeof cycle.last_state_path === 'string' ? cycle.last_state_path : null,
+    last_verdict: typeof cycle.last_verdict === 'string' ? cycle.last_verdict : null,
+    findings_packet: cycle.findings_packet && typeof cycle.findings_packet === 'object' ? cycle.findings_packet : null,
+    repair: cycle.repair && typeof cycle.repair === 'object'
+      ? {
+        skill: typeof cycle.repair.skill === 'string' ? cycle.repair.skill : WORKFLOW_CONFIG.skills.findings_repair,
+        status: typeof cycle.repair.status === 'string' ? cycle.repair.status : 'not_needed',
+        required_from_attempt: Number.isInteger(cycle.repair.required_from_attempt) ? cycle.repair.required_from_attempt : null,
+        requested_at: typeof cycle.repair.requested_at === 'string' ? cycle.repair.requested_at : null,
+        completed_at: typeof cycle.repair.completed_at === 'string' ? cycle.repair.completed_at : null,
+        active: cycle.repair.active && typeof cycle.repair.active === 'object' ? cycle.repair.active : null,
+      }
+      : {
+        skill: WORKFLOW_CONFIG.skills.findings_repair,
+        status: 'not_needed',
+        required_from_attempt: null,
+        requested_at: null,
+        completed_at: null,
+        active: null,
+      },
+    history: Array.isArray(cycle.history) ? cycle.history : [],
+  };
+}
+
+function patchValidatorResult(runId, result, args = {}) {
+  const previous = readState(runId, args);
+  const current = normalizeValidatorCycle(previous.data?.validator_cycle ?? {});
+  const history = [
+    ...current.history,
+    {
+      timestamp: result.timestamp,
+      action: result.action,
+      status: result.status,
+      validator_status: result.validator_status ?? null,
+      validator_attempt: result.validator_attempt ?? null,
+      validator_run_id: result.validator_run_id ?? null,
+      repair_run_id: result.repair_run_id ?? null,
+      state_path: result.state_path ?? null,
+      next_action: result.next_action ?? null,
+      error: result.error ?? null,
+    },
+  ];
+  const data = {
+    ...(previous.data ?? {}),
+    validator_cycle: {
+      ...current,
+      ...(result.validator_cycle ?? {}),
+      history,
+    },
+    gates: {
+      ...(previous.data?.gates ?? {}),
+      [result.gate ?? 'G4']: redact(result),
+    },
+  };
+
+  return upsertState({
+    run_id: runId,
+    project_root: args.project_root,
+    phase: previous.phase ?? 'dispatch',
+    status: result.status === 'passed' ? 'validator_gate_ok' : 'validator_gate_blocked',
+    summary: `${result.gate ?? 'G4'}: ${result.status}`,
+    data,
+  });
+}
+
+// S10: deriva o slot de recovery para um orquestrador re-spun reconhecer de forma
+// determinística qual retorno aceitar. Aditivo, não-quebrante: campo top-level
+// `validator_recovery` no retorno de leitura (null quando não há slot ativo).
+// Construído na leitura (fora do caminho de persistência/redact), então
+// `expected_dispatch_token` não é redigido — não reabre a chave genérica `token`.
+function deriveValidatorRecovery(state) {
+  const cycle = state?.data?.validator_cycle;
+  const active = cycle && typeof cycle === 'object' ? cycle.active : null;
+  if (!active || typeof active !== 'object') return null;
+  return {
+    expected_validator_run_id: typeof active.run_id === 'string' ? active.run_id : null,
+    expected_dispatch_token: Number.isInteger(active.dispatch_token) ? active.dispatch_token : null,
+    expected_state_path: typeof active.state_path === 'string' ? active.state_path : null,
+    attempt: Number.isInteger(active.attempt) ? active.attempt : null,
+    status: typeof cycle.status === 'string' ? cycle.status : null,
+    // P1.1: challenge de proof-of-work do slot ativo (null se não emitido). O
+    // validador irmão lê isto, computa sha256 do arquivo e devolve em challenge_response.
+    challenge: active.challenge && typeof active.challenge === 'object' ? active.challenge : null,
+  };
+}
+
+function runState(args = {}) {
+  const action = args.action ?? 'get';
+  if (action === 'get') {
+    const state = readState(validateRunId(args.run_id), args);
+    return { ...state, validator_recovery: deriveValidatorRecovery(state) };
+  }
+  if (action === 'upsert') return upsertState(args);
+  throw rpcError(-32602, `Ação inválida para atlas_run_state: ${action}`);
+}
+
+function verifyArtifact(args = {}) {
+  const runId = validateRunId(args.run_id);
+  const artifactPath = requiredString(args, 'artifact_path');
+  const absolutePath = resolveConsumerPath(artifactPath, args);
+  const timestamp = nowIso();
+  // Banner correto por tipo de artefato: verificar um PRD não pode ecoar
+  // "plano · validado". `artifact_kind` é opcional e aditivo — `prd` → banner de
+  // PRD; ausente/`plan` mantém o banner de plano (compat com callers antigos que
+  // só verificavam plano).
+  const artifactKind = optionalString(args, 'artifact_kind');
+  const okBanner = artifactKind === 'prd'
+    ? renderBanner('prd_ok', {})
+    : renderBanner('plano', {});
+  let result;
+
+  try {
+    const stat = fs.statSync(absolutePath);
+    if (!stat.isFile()) {
+      result = {
+        gate: 'G1',
+        status: 'blocked',
+        artifact_path: artifactPath,
+        timestamp,
+        banner: renderBanner('preflight_fail', { motivo: `artefato inválido: ${artifactPath}` }),
+        error: `Artefato não é arquivo legível: ${artifactPath}`,
+        next_action: 'corrigir_artefato',
+      };
+    } else {
+      fs.accessSync(absolutePath, fs.constants.R_OK);
+      result = {
+        gate: 'G1',
+        status: 'passed',
+        artifact_path: artifactPath,
+        bytes: stat.size,
+        timestamp,
+        banner: okBanner,
+        next_action: 'avançar',
+      };
+    }
+  } catch (error) {
+    result = {
+      gate: 'G1',
+      status: 'blocked',
+      artifact_path: artifactPath,
+      timestamp,
+      banner: renderBanner('preflight_fail', { motivo: `artefato ausente: ${artifactPath}` }),
+      error: `Artefato ausente ou ilegível: ${artifactPath}`,
+      cause: error.message,
+      next_action: 'corrigir_artefato',
+    };
+  }
+
+  patchGateResult(runId, 'G1', result, args);
+  return result;
+}
+
+function splitPrdSections(content) {
+  const sections = {};
+  let current = null;
+  const lines = content.split(/\r?\n/);
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const matched = Object.entries(SECTION_HEADING).find(([, regex]) => regex.test(line));
+    if (matched) current = matched[0];
+    if (current) {
+      sections[current] ??= [];
+      sections[current].push({ line: index + 1, text: line });
+    }
+  }
+
+  return sections;
+}
+
+function lineIsExcluded(line) {
+  return line.toLowerCase().includes('depende de plano');
+}
+
+function scanSectionPatterns(sections) {
+  const matches = [];
+
+  for (const [sectionKey, patterns] of Object.entries(PRD_PATTERNS)) {
+    const lines = sections[sectionKey] ?? [];
+    const sectionText = lines.map((line) => line.text).join('\n').trim();
+
+    if (sectionKey === 'section_3_decisions') {
+      const hasDecisionRows = /\|\s*D\d+\s*\|/.test(sectionText);
+      if (!hasDecisionRows) {
+        matches.push({
+          section: SECTION_LABELS[sectionKey],
+          pattern: '(empty or minimal content)',
+          line: lines[0]?.line ?? null,
+          excerpt: 'Seção sem decisão D* fechada.',
+          reason: 'Decisões de produto vazias ou mínimas bloqueiam planejamento.',
+        });
+      }
+    }
+
+    for (const { line, text } of lines) {
+      if (lineIsExcluded(text)) continue;
+      const lower = text.toLowerCase();
+      for (const pattern of patterns) {
+        if (lower.includes(pattern.toLowerCase())) {
+          matches.push({
+            section: SECTION_LABELS[sectionKey],
+            pattern,
+            line,
+            excerpt: text.trim().slice(0, 240),
+            reason: 'Padrão de ambiguidade bloqueante detectado.',
+          });
+        }
+      }
+    }
+  }
+
+  return matches;
+}
+
+function scanPrd(args = {}) {
+  const runId = validateRunId(args.run_id);
+  const prdPath = requiredString(args, 'prd_path');
+  const absolutePath = resolveConsumerPath(prdPath, args);
+  const timestamp = nowIso();
+  let result;
+
+  try {
+    const content = fs.readFileSync(absolutePath, 'utf8');
+    if (content.trim() === '') {
+      result = {
+        gate: 'G5',
+        status: 'blocked',
+        prd_path: prdPath,
+        timestamp,
+        blocking_count: 1,
+        banner: renderBanner('prd_lacunas', { n: 1 }),
+        blocking_matches: [{
+          section: 'documento',
+          pattern: '(empty file)',
+          line: null,
+          excerpt: '',
+          reason: 'PRD vazio não pode avançar como documento pronto.',
+        }],
+        next_action: 'entrevista',
+      };
+    } else {
+      const blockingMatches = scanSectionPatterns(splitPrdSections(content));
+      result = {
+        gate: 'G5',
+        status: blockingMatches.length === 0 ? 'passed' : 'blocked',
+        prd_path: prdPath,
+        timestamp,
+        blocking_count: blockingMatches.length,
+        banner: blockingMatches.length === 0
+          ? renderBanner('prd_ok', {})
+          : renderBanner('prd_lacunas', { n: blockingMatches.length }),
+        blocking_matches: blockingMatches,
+        next_action: blockingMatches.length === 0 ? 'avançar' : 'entrevista',
+        message: blockingMatches.length === 0
+          ? 'Ambiguity scan: 0 padrões bloqueantes — entrevista pulada'
+          : 'Ambiguity scan: padrões bloqueantes encontrados — entrevista obrigatória',
+      };
+    }
+  } catch (error) {
+    result = {
+      gate: 'G5',
+      status: 'blocked',
+      prd_path: prdPath,
+      timestamp,
+      blocking_count: 1,
+      banner: renderBanner('prd_lacunas', { n: 1 }),
+      blocking_matches: [{
+        section: 'documento',
+        pattern: '(read error)',
+        line: null,
+        excerpt: '',
+        reason: `PRD ilegível: ${prdPath}`,
+      }],
+      error: `PRD ausente ou ilegível: ${prdPath}`,
+      cause: error.message,
+      next_action: 'entrevista',
+    };
+  }
+
+  patchGateResult(runId, 'G5', result, args);
+  return result;
+}
+
+function collectHeadings(content) {
+  const headings = new Map();
+  for (const [index, line] of content.split(/\r?\n/).entries()) {
+    const match = /^##\s+(\d+)\.\s+(.+?)\s*$/.exec(line);
+    if (match) headings.set(match[1], { title: match[2], line: index + 1 });
+  }
+  return headings;
+}
+
+function hasRequiredStatus(content, requiredStatus) {
+  const regex = new RegExp(`\\|\\s*\\*\\*Status\\*\\*\\s*\\|\\s*${requiredStatus.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*\\|`, 'i');
+  return regex.test(content);
+}
+
+function conformancePending(category, item, line, message, nextAction = 'corrigir_artefato') {
+  return { category, item, line, message, next_action: nextAction };
+}
+
+function verifyRequiredSections(headings, requiredSections) {
+  return requiredSections
+    .filter(([number]) => !headings.has(number))
+    .map(([number, title]) => conformancePending(
+      'seção_obrigatória',
+      `§${number} ${title}`,
+      null,
+      `Seção obrigatória ausente: §${number} ${title}`,
+    ));
+}
+
+function verifyPrdConformance(content, requiredStatus) {
+  const pendencies = verifyRequiredSections(collectHeadings(content), REQUIRED_PRD_SECTIONS);
+
+  if (requiredStatus && !hasRequiredStatus(content, requiredStatus)) {
+    pendencies.push(conformancePending(
+      'status',
+      requiredStatus,
+      null,
+      `Status documental requerido ausente: ${requiredStatus}`,
+      'ajustar_status_documental',
+    ));
+  }
+
+  if (!/\|\s*D\d+\s*\|/.test(content)) {
+    pendencies.push(conformancePending(
+      'decisões',
+      'D*',
+      null,
+      'PRD sem decisões D* fechadas.',
+      'registrar_decisoes_fechadas',
+    ));
+  }
+
+  for (const group of ['Produto', 'UX', 'Dados', 'Regressão de produto']) {
+    if (!new RegExp(`\\*\\*${group}\\*\\*`, 'i').test(content)) {
+      pendencies.push(conformancePending(
+        'critérios_de_aceite',
+        group,
+        null,
+        `Grupo de critérios ausente: ${group}`,
+        'completar_criterios_de_aceite',
+      ));
+    }
+  }
+
+  const checkboxCount = (content.match(/^- \[[ xX]\]\s+\S/gm) ?? []).length;
+  if (checkboxCount === 0) {
+    pendencies.push(conformancePending(
+      'critérios_de_aceite',
+      'checkboxes',
+      null,
+      'Critérios de aceite observáveis não encontrados.',
+      'completar_criterios_de_aceite',
+    ));
+  }
+
+  return pendencies;
+}
+
+function verifyPlanConformance(content) {
+  // §7 Slices só é obrigatória em `execution_mode: orchestrated-per-slice` (template).
+  // Em `sequencial` a seção é dispensável — não force "§7 Não aplicável" só para passar
+  // o gate (S1). Verdade forte = presença do literal orchestrated-per-slice no cabeçalho.
+  const orchestratedPerSlice = /orchestrated-per-slice/i.test(content);
+  const requiredSections = orchestratedPerSlice
+    ? REQUIRED_PLAN_SECTIONS
+    : REQUIRED_PLAN_SECTIONS.filter(([number]) => number !== '7');
+  const pendencies = verifyRequiredSections(collectHeadings(content), requiredSections);
+
+  if (!/\|\s*\*\*PRD\*\*\s*\|/.test(content)) {
+    pendencies.push(conformancePending(
+      'referência_prd',
+      'PRD',
+      null,
+      'Plano sem link/campo PRD no cabeçalho.',
+      'vincular_prd',
+    ));
+  }
+
+  if (!/####\s+T\d+\./.test(content)) {
+    pendencies.push(conformancePending(
+      'tarefas',
+      'T01..Tn',
+      null,
+      'Plano sem tarefas numeradas T01..Tn.',
+      'criar_tarefas_numeradas',
+    ));
+  }
+
+  if (!/BOUNDARY_PRD_PLAN\.md/.test(content)) {
+    pendencies.push(conformancePending(
+      'boundary',
+      'BOUNDARY_PRD_PLAN.md',
+      null,
+      'Plano sem referência à fronteira PRD/PLAN.',
+      'vincular_boundary',
+    ));
+  }
+
+  return pendencies;
+}
+
+function verifyTemplateConformance(args = {}) {
+  const runId = validateRunId(args.run_id);
+  const artifactPath = requiredString(args, 'artifact_path');
+  const artifactType = requiredString(args, 'artifact_type');
+  if (!['prd', 'plan'].includes(artifactType)) {
+    throw rpcError(-32602, 'artifact_type inválido: use prd ou plan');
+  }
+
+  const requiredStatus = optionalString(args, 'required_status');
+  const absolutePath = resolveConsumerPath(artifactPath, args);
+  const timestamp = nowIso();
+  let result;
+
+  try {
+    const content = fs.readFileSync(absolutePath, 'utf8');
+    if (content.trim() === '') {
+      result = {
+        gate: 'template_conformance',
+        status: 'blocked',
+        artifact_type: artifactType,
+        artifact_path: artifactPath,
+        timestamp,
+        pending_count: 1,
+        banner: renderBanner('preflight_fail', { motivo: `TC ${artifactType}: arquivo vazio` }),
+        pendencies: [conformancePending(
+          'documento',
+          'arquivo_vazio',
+          null,
+          'Artefato vazio não pode passar em conformidade.',
+        )],
+        next_action: 'corrigir_artefato',
+      };
+    } else {
+      const pendencies = artifactType === 'prd'
+        ? verifyPrdConformance(content, requiredStatus)
+        : verifyPlanConformance(content);
+      result = {
+        gate: 'template_conformance',
+        status: pendencies.length === 0 ? 'passed' : 'blocked',
+        artifact_type: artifactType,
+        artifact_path: artifactPath,
+        required_status: requiredStatus ?? null,
+        timestamp,
+        pending_count: pendencies.length,
+        banner: pendencies.length === 0
+          ? renderBanner('plano', {})
+          : renderBanner('preflight_fail', { motivo: `TC ${artifactType}: ${pendencies.length} pendências` }),
+        pendencies,
+        next_action: pendencies.length === 0 ? 'avançar' : pendencies[0].next_action,
+      };
+    }
+  } catch (error) {
+    result = {
+      gate: 'template_conformance',
+      status: 'blocked',
+      artifact_type: artifactType,
+      artifact_path: artifactPath,
+      timestamp,
+      pending_count: 1,
+      banner: renderBanner('preflight_fail', { motivo: `TC ${artifactType}: artefato ilegível` }),
+      pendencies: [conformancePending(
+        'leitura',
+        artifactPath,
+        null,
+        `Artefato ausente ou ilegível: ${artifactPath}`,
+      )],
+      error: `Artefato ausente ou ilegível: ${artifactPath}`,
+      cause: error.message,
+      next_action: 'corrigir_artefato',
+    };
+  }
+
+  patchTemplateConformanceResult(runId, result, args);
+  return result;
+}
+
+// Detecta tipo de input para roteamento (PRD D4/D5). Hierarquia de confiança:
+//   (1) verdade forte: conformidade de template de plano passa → 'plan';
+//   (2) dica: cabeçalho/frontmatter canônico de plano → 'plan';
+//   (3) dica fraca: nome casando PLAN_*.md → 'plan';
+//   PRD/backlog por marcadores de template; senão 'unknown'.
+// Nome de arquivo nunca basta sozinho nem engana (PRD §5 Contrato): só conta como dica
+// fraca e cede para a verdade forte. Reusa verifyPlanConformance para (1).
+function classifyArtifactContent(content, fileName = '') {
+  const text = content ?? '';
+
+  // (1) Verdade forte: plano conforme o template canônico (zero pendências).
+  if (text.trim() !== '' && verifyPlanConformance(text).length === 0) {
+    return { artifact_type: 'plan', signal: 'template_conformance' };
+  }
+
+  // (2) Dica de cabeçalho/frontmatter canônico de plano.
+  const planHeaderHint = /\|\s*\*\*PRD\*\*\s*\|/.test(text)
+    || /^#\s+PLAN[\s_]/im.test(text)
+    || /\bexecution_mode\b/.test(text);
+  if (planHeaderHint && /####\s+T\d+\./.test(text)) {
+    return { artifact_type: 'plan', signal: 'header_hint' };
+  }
+
+  // PRD: marcadores do template canônico de PRD.
+  const prdHint = /^#\s+PRD[:\s]/im.test(text)
+    || /\|\s*D\d+\s*\|/.test(text)
+    || /Decisões de produto/i.test(text);
+  if (prdHint) {
+    return { artifact_type: 'prd', signal: 'prd_markers' };
+  }
+
+  // Backlog: marcadores do template canônico de backlog/roadmap.
+  const backlogHint = /\bBACKLOG[\s_]/i.test(text)
+    || /\bSprint\s+S\d+/i.test(text)
+    || /\bRoadmap\b/i.test(text);
+  if (backlogHint) {
+    return { artifact_type: 'backlog', signal: 'backlog_markers' };
+  }
+
+  // (3) Dica fraca: nome PLAN_*.md, só se nada mais classificou.
+  if (/(^|\/)PLAN_[^/]*\.md$/i.test(fileName)) {
+    return { artifact_type: 'plan', signal: 'weak_name_hint' };
+  }
+
+  return { artifact_type: 'unknown', signal: 'no_match' };
+}
+
+function classifyInput(args = {}) {
+  const runId = validateRunId(args.run_id);
+  const inputPath = requiredString(args, 'input_path');
+  const absolutePath = resolveConsumerPath(inputPath, args);
+  const timestamp = nowIso();
+  let result;
+
+  // Input que não é arquivo existente = descrição livre (idea), não path. Heurística
+  // determinística: parece path só se terminar em extensão de arquivo E não tiver espaço.
+  // Idea NÃO é "input ilegível" — roteia para `direct` sem BLOCK falso-positivo (A6).
+  // Path com cara de arquivo mas ausente/ilegível continua caindo no catch (erro real).
+  const trimmedInput = inputPath.trim();
+  const looksLikePath = /\.[a-z0-9]{1,6}$/i.test(trimmedInput) && !/\s/.test(trimmedInput);
+  if (!looksLikePath && !fs.existsSync(absolutePath)) {
+    return {
+      gate: 'classify_input',
+      status: 'not_a_file',
+      input_path: inputPath,
+      artifact_type: 'idea',
+      routed_mode: ROUTED_MODE_BY_TYPE.idea,
+      detection_signal: 'free_text_idea',
+      timestamp,
+      banner: renderBanner('roteia', { tipo: 'idea', modo: ROUTED_MODE_BY_TYPE.idea }),
+      next_action: 'rotear_idea_para_direct',
+    };
+  }
+
+  try {
+    const content = fs.readFileSync(absolutePath, 'utf8');
+    const { artifact_type, signal } = classifyArtifactContent(content, inputPath);
+    // Modo-alvo por tipo de input (PRD D3/D6): o fato manda. plan → execute;
+    // prd/backlog → full (gera/usa plano). Data-driven; sem ramo solto.
+    const routedMode = ROUTED_MODE_BY_TYPE[artifact_type] ?? null;
+    result = {
+      gate: 'classify_input',
+      status: artifact_type === 'unknown' ? 'unknown' : 'classified',
+      input_path: inputPath,
+      artifact_type,
+      routed_mode: routedMode,
+      detection_signal: signal,
+      timestamp,
+      // Banner canônico do banco (T06/T07): roteamento por tipo de input.
+      banner: artifact_type === 'unknown'
+        ? renderBanner('preflight_fail', { motivo: `input não classificado: ${inputPath}` })
+        : renderBanner('roteia', { tipo: artifact_type, modo: routedMode }),
+      next_action: artifact_type === 'unknown' ? 'pedir_esclarecimento' : 'rotear_por_tipo',
+    };
+  } catch (error) {
+    result = {
+      gate: 'classify_input',
+      status: 'blocked',
+      input_path: inputPath,
+      artifact_type: 'unknown',
+      timestamp,
+      banner: renderBanner('preflight_fail', { motivo: `input ilegível: ${inputPath}` }),
+      error: `Input ausente ou ilegível: ${inputPath}`,
+      cause: error.message,
+      next_action: 'corrigir_input',
+    };
+  }
+
+  return result;
+}
+
+function preflight(args = {}) {
+  const runId = validateRunId(args.run_id);
+  if (Object.prototype.hasOwnProperty.call(args, LEGACY_ROUTE_KEY)) {
+    throw rpcError(-32602, `unknown_property: ${LEGACY_ROUTE_KEY}`);
+  }
+  const mode = requiredString(args, 'mode');
+  const expectedVersion = optionalString(args, 'expected_version');
+  const config = parseWorkflowConfig();
+  const version = readVersionInfo();
+  const activeConflict = findActiveRunConflict(runId, args);
+  const timestamp = nowIso();
+  let previous = null;
+
+  try {
+    previous = readState(runId, args);
+  } catch (error) {
+    if (error.code !== -32004) throw error;
+  }
+
+  const currentRouting = previous?.data?.routing;
+  let result;
+
+  const prereq = checkPrerequisites(args);
+  const join = checkJoinCapability(args);
+  if (prereq.status === 'blocked') {
+    result = {
+      gate: 'PREREQ',
+      status: 'blocked',
+      timestamp,
+      mode,
+      host: prereq.host,
+      missing_prerequisites: prereq.missing,
+      effective_flags: prereq.effective_flags,
+      error: prereq.error,
+      cause: prereq.cause,
+      impact: prereq.impact,
+      next_action: prereq.next_action,
+    };
+  } else if (join.status === 'blocked') {
+    // Gate JOIN após PREREQ passar (ordem determinística: prereq → join → versão/lock).
+    result = {
+      gate: 'JOIN',
+      status: 'blocked',
+      timestamp,
+      mode,
+      host: join.host,
+      error: join.error,
+      cause: join.cause,
+      impact: join.impact,
+      next_action: join.next_action,
+    };
+  } else if (version.status === 'blocked') {
+    result = {
+      gate: 'VERSION_DRIFT',
+      status: 'blocked',
+      timestamp,
+      mode,
+      version,
+      error: version.error,
+      cause: version.error,
+      impact: 'pipeline_hibrido_poderia_gerar_artefato_invalido',
+      next_action: version.next_action,
+    };
+  } else if (expectedVersion && expectedVersion !== version.version) {
+    result = {
+      gate: 'VERSION_DRIFT',
+      status: 'blocked',
+      timestamp,
+      mode,
+      expected_version: expectedVersion,
+      received_version: version.version,
+      error: `Drift de versão: esperado ${expectedVersion}, MCP reportou ${version.version}`,
+      cause: 'expected_version_diverge_do_mcp',
+      impact: 'pipeline_hibrido_poderia_gerar_artefato_invalido',
+      next_action: 'alinhar_versao_do_host_ou_reinstalar_plugin',
+    };
+  } else if (activeConflict.status === 'blocked') {
+    result = {
+      gate: 'LOCK_CONFLICT',
+      status: 'blocked',
+      timestamp,
+      mode,
+      error: activeConflict.error,
+      cause: activeConflict.cause ?? null,
+      impact: activeConflict.impact ?? 'workflow_bloqueado_para_preservar_integridade_do_ledger',
+      conflicting_run_id: activeConflict.conflicting_run_id ?? null,
+      active_phase: activeConflict.active_phase ?? null,
+      next_action: activeConflict.next_action,
+    };
+  } else if (!config.modes.includes(mode)) {
+    result = {
+      gate: 'G10',
+      status: 'blocked',
+      timestamp,
+      mode,
+      error: `Modo inválido: ${mode}`,
+      supported_modes: config.modes,
+      next_action: 'corrigir_rota',
+    };
+  } else if (currentRouting && currentRouting.mode !== mode) {
+      result = {
+        gate: 'G10',
+        status: 'blocked',
+        timestamp,
+        mode,
+        locked_mode: currentRouting.mode,
+        error: `Troca de modo bloqueada: ${currentRouting.mode} -> ${mode}`,
+        next_action: 'encerrar_run_ou_usar_modo_travado',
+      };
+  } else {
+    const guaranteeLevel = guaranteeLevelForMode(mode);
+    // Campo OMITIDO quando o modo não declara garantia (interview-only → null).
+    result = {
+      gate: 'G10',
+      status: 'passed',
+      timestamp,
+      mode,
+      ...(guaranteeLevel ? { guarantee_level: guaranteeLevel } : {}),
+      routing: {
+        mode,
+        ...(guaranteeLevel ? { guarantee_level: guaranteeLevel } : {}),
+        skills: config.skills,
+        version: version.version,
+        locked_at: currentRouting?.locked_at ?? timestamp,
+        config_path: config.path,
+        supported_modes: config.modes,
+      },
+      next_action: 'avançar',
+    };
+  }
+
+  // Banner canônico do preflight (T07): passed → preflight_ok com caps efetivas;
+  // qualquer block → preflight_fail com motivo derivado do gate/erro. Derivado do
+  // status final (não espalha string por branch) — fonte única no banco BANNER_TEMPLATES.
+  if (result.status === 'passed') {
+    result.banner = renderBanner('preflight_ok', { caps: 'subagent+mcp' });
+  } else {
+    const motivo = result.error
+      ? String(result.error).slice(0, 80)
+      : `${result.gate} bloqueado`;
+    result.banner = renderBanner('preflight_fail', { motivo });
+  }
+
+  patchRoutingResult(runId, result, args);
+  return result;
+}
+
+function getDispatchState(runId, args = {}) {
+  const state = readState(runId, args);
+  const routing = state.data?.routing;
+  if (!routing) {
+    throw rpcError(-32011, 'Preflight não executado: execute atlas_preflight antes do dispatch', {
+      run_id: runId,
+    });
+  }
+  return { state, routing, dispatch: state.data?.dispatch ?? {} };
+}
+
+function expectedNextPhase(routing, dispatch) {
+  if (dispatch.next_phase) return dispatch.next_phase;
+  if (routing.mode === 'full') return 'plan_handoff';
+  if (routing.mode === 'direct') return 'plan_execute';
+  if (routing.mode === 'execute') return 'plan_execute';
+  return 'prd_interview';
+}
+
+function startDispatch(args, context) {
+  const phase = requiredString(args, 'phase');
+  if (Object.prototype.hasOwnProperty.call(args, LEGACY_ROUTE_KEY)) {
+    throw rpcError(-32602, `unknown_property: ${LEGACY_ROUTE_KEY}`);
+  }
+  const timestamp = nowIso();
+
+  if (context.dispatch.active) {
+    return {
+      gate: 'G7',
+      action: 'start',
+      phase,
+      status: 'blocked',
+      timestamp,
+      error: `Dispatch paralelo bloqueado: fase ativa ${context.dispatch.active.phase}`,
+      current_phase: context.dispatch.active.phase,
+      expected_phase: context.dispatch.active.phase,
+      next_action: 'aguardar_fase_ativa',
+    };
+  }
+
+  if (phase === 'slice_review' && !context.dispatch.execution_completed) {
+    return {
+      gate: 'G8',
+      action: 'start',
+      phase,
+      status: 'blocked',
+      timestamp,
+      error: 'Review bloqueado: execução ainda não concluída com validator',
+      current_phase: context.dispatch.previous_phase ?? null,
+      expected_phase: 'plan_execute',
+      next_action: 'dispatch_plan_execute_blocking',
+    };
+  }
+
+  const expected = expectedNextPhase(context.routing, context.dispatch);
+  if (phase !== expected && phase !== 'slice_review') {
+    return {
+      gate: 'G7',
+      action: 'start',
+      phase,
+      status: 'blocked',
+      timestamp,
+      error: `Fase fora de ordem: esperado ${expected}, recebido ${phase}`,
+      current_phase: context.dispatch.previous_phase ?? null,
+      expected_phase: expected,
+      next_action: `dispatch_${expected}`,
+    };
+  }
+
+  return {
+    gate: 'G7',
+    action: 'start',
+    phase,
+    status: 'passed',
+    timestamp,
+    current_phase: phase,
+    expected_phase: expected,
+    dispatch: {
+      active: { phase, started_at: timestamp },
+      previous_phase: context.dispatch.previous_phase ?? null,
+      next_phase: null,
+      next_action: `complete_${phase}`,
+    },
+    next_action: `complete_${phase}`,
+  };
+}
+
+function completeDispatch(args, context) {
+  const phase = requiredString(args, 'phase');
+  const timestamp = nowIso();
+  const active = context.dispatch.active;
+
+  if (!active || active.phase !== phase) {
+    return {
+      gate: 'G7',
+      action: 'complete',
+      phase,
+      status: 'blocked',
+      timestamp,
+      error: `Conclusão 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 ? `complete_${active.phase}` : `dispatch_${expectedNextPhase(context.routing, context.dispatch)}`,
+    };
+  }
+
+  if (phase === 'plan_handoff' && context.routing.mode === 'full') {
+    return {
+      gate: 'G11',
+      action: 'complete',
+      phase,
+      status: 'passed',
+      timestamp,
+      dispatch: {
+        active: null,
+        previous_phase: phase,
+        plan_validated: true,
+        next_phase: 'plan_execute',
+        next_action: 'dispatch_plan_execute_blocking',
+      },
+      next_action: 'dispatch_plan_execute_blocking',
+    };
+  }
+
+  if (phase === 'plan_execute') {
+    const validatorStatus = requiredString(args, 'validator_status');
+    if (!VALIDATOR_PASSED_STATUSES.has(validatorStatus)) {
+      return {
+        gate: 'G8',
+        action: 'complete',
+        phase,
+        status: 'blocked',
+        timestamp,
+        error: `Execução não pode concluir sem validator terminal aprovado; recebido ${validatorStatus}`,
+        current_phase: phase,
+        expected_phase: 'task_validator',
+        next_action: 'rodar_task_validator_antes_do_review',
+      };
+    }
+    return {
+      gate: 'G8',
+      action: 'complete',
+      phase,
+      status: 'passed',
+      timestamp,
+      validator_status: validatorStatus,
+      dispatch: {
+        active: null,
+        previous_phase: phase,
+        execution_completed: true,
+        validator_status: validatorStatus,
+        next_phase: 'slice_review',
+        next_action: 'review_optional_or_complete',
+      },
+      next_action: 'review_optional_or_complete',
+    };
+  }
+
+  if (phase === 'slice_review') {
+    return {
+      gate: 'G8',
+      action: 'complete',
+      phase,
+      status: 'passed',
+      timestamp,
+      dispatch: {
+        active: null,
+        previous_phase: phase,
+        review_completed: true,
+        next_phase: null,
+        next_action: 'complete_allowed',
+      },
+      next_action: 'complete_allowed',
+    };
+  }
+
+  return {
+    gate: 'G7',
+    action: 'complete',
+    phase,
+    status: 'passed',
+    timestamp,
+    dispatch: {
+      active: null,
+      previous_phase: phase,
+      next_phase: expectedNextPhase(context.routing, context.dispatch),
+      next_action: `dispatch_${expectedNextPhase(context.routing, context.dispatch)}`,
+    },
+    next_action: `dispatch_${expectedNextPhase(context.routing, context.dispatch)}`,
+  };
+}
+
+function abortDispatch(args, context) {
+  const phase = requiredString(args, 'phase');
+  const timestamp = nowIso();
+  const active = context.dispatch.active;
+  const result = {
+    gate: 'G7',
+    action: 'abort',
+    phase,
+    status: active?.phase === phase ? 'passed' : 'blocked',
+    timestamp,
+    error: active?.phase === phase ? null : `Abort fora de ordem: fase ativa ${active?.phase ?? 'nenhuma'}, recebido ${phase}`,
+    current_phase: active?.phase ?? null,
+    expected_phase: active?.phase ?? null,
+    dispatch: active?.phase === phase ? {
+      active: null,
+      previous_phase: phase,
+      next_phase: phase,
+      next_action: `retry_${phase}`,
+    } : {},
+    next_action: active?.phase === phase ? `retry_${phase}` : `complete_${active?.phase ?? expectedNextPhase(context.routing, context.dispatch)}`,
+  };
+  return result;
+}
+
+function lockDispatch(args = {}) {
+  const runId = validateRunId(args.run_id);
+  if (Object.prototype.hasOwnProperty.call(args, LEGACY_ROUTE_KEY)) {
+    throw rpcError(-32602, `unknown_property: ${LEGACY_ROUTE_KEY}`);
+  }
+  const action = args.action ?? 'start';
+  if (!['start', '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 === 'complete' ? completeDispatch(args, context) :
+    abortDispatch(args, context);
+
+  result.banner = dispatchBanner(result);
+  patchDispatchResult(runId, result, args);
+  return result;
+}
+
+// Proof-of-work do validador irmão (P1.1 camada 1). Escopo HONESTO: não é prova
+// criptográfica de isolamento (o MCP fala stdio com um único caller e não distingue
+// orquestrador de subagente). É atestação mecânica de que o veredito tocou bytes
+// reais do boundary — eleva o piso do atalho preguiçoso (afirmar `pass` sem ler
+// código) e dá rastro de auditoria. Pegar 1 arquivo do `files_changed` do
+// `state_path`; o validador reporta o sha256 dele; o MCP RECOMPUTA do disco no
+// complete (nunca armazena o hash esperado em estado legível — senão o orquestrador
+// só copiaria). Best-effort: sem arquivo legível ⇒ challenge null ⇒ sem enforcement
+// (não quebra run válida). Seleção determinística por dispatch_token (reproduzível).
+function pickValidatorChallenge(statePathValue, args, dispatchToken) {
+  try {
+    const sliceState = JSON.parse(fs.readFileSync(resolveConsumerPath(statePathValue, args), 'utf8'));
+    const files = Array.isArray(sliceState.files_changed)
+      ? sliceState.files_changed.filter((f) => typeof f === 'string' && f.trim() !== '')
+      : [];
+    if (files.length === 0) return null;
+    const offset = ((dispatchToken % files.length) + files.length) % files.length;
+    for (let i = 0; i < files.length; i += 1) {
+      const rel = files[(offset + i) % files.length];
+      try {
+        const fabs = resolveConsumerPath(rel, args);
+        if (!fs.statSync(fabs).isFile()) continue;
+        fs.accessSync(fabs, fs.constants.R_OK);
+        return { file: rel, algo: 'sha256' };
+      } catch {
+        // arquivo do boundary inexistente/ilegível (ex.: deletado na slice) — tenta o próximo.
+      }
+    }
+    return null;
+  } catch {
+    // state_path ilegível aqui não bloqueia o start (o validador falha do lado dele
+    // se não conseguir ler o boundary); proof-of-work é aditivo.
+    return null;
+  }
+}
+
+// Verifica o challenge_response no complete recomputando o hash do disco.
+//   { ok: true }                         — sem challenge emitido OU hash confere
+//   { ok: true, unverifiable: true }     — arquivo sumiu no complete (não bloqueia)
+//   { ok: false, reason }                — resposta ausente ou hash divergente
+function verifyValidatorChallenge(challenge, response, args) {
+  if (!challenge || typeof challenge.file !== 'string') return { ok: true };
+  if (typeof response !== 'string' || response.trim() === '') {
+    return { ok: false, reason: 'challenge_response_ausente' };
+  }
+  let actual;
+  try {
+    actual = crypto.createHash('sha256')
+      .update(fs.readFileSync(resolveConsumerPath(challenge.file, args)))
+      .digest('hex');
+  } catch {
+    return { ok: true, unverifiable: true };
+  }
+  // Aceita hex puro ou saída de `shasum` (`<hash>  <arquivo>`): primeiro token.
+  const submitted = response.trim().toLowerCase().split(/\s+/)[0];
+  return submitted === actual ? { ok: true } : { ok: false, reason: 'challenge_hash_divergente' };
+}
+
+function validatorStart(args, context) {
+  const runId = validateRunId(args.run_id);
+  const statePathValue = requiredString(args, 'state_path');
+  const timestamp = nowIso();
+  const cycle = normalizeValidatorCycle(context.state.data?.validator_cycle ?? {});
+
+  if (context.dispatch.active?.phase !== 'plan_execute') {
+    return {
+      gate: 'G4',
+      action: 'start',
+      status: 'blocked',
+      timestamp,
+      error: 'Validator só pode iniciar com plan_execute ativo',
+      current_phase: context.dispatch.active?.phase ?? null,
+      next_action: 'manter_plan_execute_ativo_antes_da_validacao',
+    };
+  }
+
+  if (cycle.active) {
+    return {
+      gate: 'G4',
+      action: 'start',
+      status: 'blocked',
+      timestamp,
+      error: `Validator já está ativo (attempt ${cycle.active.attempt})`,
+      validator_attempt: cycle.active.attempt,
+      next_action: 'aguardar_validator_ativo',
+    };
+  }
+
+  // SPEC_FSM_SIBLING_S02 §1.3 / D-S02-2: `passed` e `passed_with_observations`
+  // são terminais SEM transição de saída. A slice fechou com sucesso; um novo
+  // validatorStart não pode reabri-la. Este guard DEVE preceder o HF-05
+  // (attempts_used >= max_attempts) porque quando o terminal é atingido no
+  // attempt 2 (último), attempts_used==max_attempts==2 — sem a prioridade
+  // correta, HF-05 dispararia primeiro retornando causa enganosa
+  // ("Terceiro validator proibido") em vez da causa real ("terminal não reabre").
+  if (VALIDATOR_PASSED_STATUSES.has(cycle.status)) {
+    return {
+      gate: 'G4',
+      action: 'start',
+      status: 'blocked',
+      timestamp,
+      error: `Ciclo do validator já concluído (${cycle.status}); terminal não reabre para novo dispatch`,
+      validator_status: cycle.status,
+      next_action: 'encerrar_slice_terminal_aprovada',
+    };
+  }
+
+  // HF-05: teto de max_attempts atingido. Só chega aqui se o ciclo NÃO está
+  // em estado terminal aprovado (guard acima já descartou esse caso).
+  if (cycle.attempts_used >= cycle.max_attempts) {
+    return {
+      gate: 'G4',
+      action: 'start',
+      status: 'blocked',
+      timestamp,
+      error: `Terceiro validator proibido: attempts=${cycle.attempts_used}, máximo=${cycle.max_attempts}`,
+      validator_attempt: cycle.attempts_used,
+      next_action: 'tratar_como_blocked_final_validator_failed',
+    };
+  }
+
+  if (cycle.status === 'blocked') {
+    return {
+      gate: 'G4',
+      action: 'start',
+      status: 'blocked',
+      timestamp,
+      error: 'Ciclo do validator já está bloqueado para esta slice',
+      next_action: 'encerrar_run_ou_reiniciar_slice_com_decisao_explicita',
+    };
+  }
+
+  if (cycle.status === 'repair_required' || cycle.status === 'repair_running') {
+    return {
+      gate: 'G4',
+      action: 'start',
+      status: 'blocked',
+      timestamp,
+      error: cycle.status === 'repair_running'
+        ? 'Retry do validator exige o término do repair ativo antes de novo dispatch'
+        : 'Retry do validator exige conclusão explícita do repair antes de novo dispatch',
+      validator_attempt: cycle.attempts_used,
+      next_action: 'complete_findings_repair',
+    };
+  }
+
+  const attempt = cycle.attempts_used + 1;
+  const activeValidatorRunId = validatorRunId(runId, attempt, timestamp);
+  // S04: token de dispatch monotônico — incrementa a cada dispatch aceito
+  // (status passed). Nunca decrementado nem reusado dentro da slice.
+  const dispatchToken = cycle.dispatch_token + 1;
+  // P1.1: challenge de proof-of-work amarrado a este attempt. null se o boundary
+  // não tem arquivo legível (best-effort, não bloqueia). Vai ao validador via
+  // validator_recovery.challenge (canal canônico) e também ecoa aqui pro log.
+  const challenge = pickValidatorChallenge(statePathValue, args, dispatchToken);
+  return {
+    gate: 'G4',
+    action: 'start',
+    status: 'passed',
+    timestamp,
+    state_path: statePathValue,
+    validator_attempt: attempt,
+    validator_run_id: activeValidatorRunId,
+    validator_status: 'running',
+    dispatch_token: dispatchToken,
+    challenge,
+    next_action: 'await_validator_verdict',
+    banner: renderBanner('validacao', { status: `running ${attempt}/${cycle.max_attempts}` }),
+    validator_cycle: {
+      dispatch_token: dispatchToken,
+      max_attempts: cycle.max_attempts,
+      attempts_used: attempt,
+      status: 'running',
+      active: {
+        attempt,
+        run_id: activeValidatorRunId,
+        state_path: statePathValue,
+        dispatch_token: dispatchToken,
+        challenge,
+        started_at: timestamp,
+      },
+      last_state_path: statePathValue,
+      repair: {
+        skill: WORKFLOW_CONFIG.skills.findings_repair,
+        status: 'not_needed',
+        required_from_attempt: null,
+        requested_at: null,
+        completed_at: null,
+        active: null,
+      },
+      findings_packet: null,
+    },
+  };
+}
+
+function validatorComplete(args, context) {
+  const timestamp = nowIso();
+  const cycle = normalizeValidatorCycle(context.state.data?.validator_cycle ?? {});
+  const statePathValue = requiredString(args, 'state_path');
+  const activeValidatorRunId = requiredString(args, 'validator_run_id');
+  const verdict = requiredString(args, 'verdict');
+  const packet = optionalData(args);
+  // S04/S16: token de dispatch é obrigatório para fechar o slot ativo. Ele vem
+  // do validator_recovery lido pela folha fria e volta no output estruturado do
+  // validator. Sem token não existe garantia anti-stale completa.
+  const dispatchToken = optionalInteger(args, 'dispatch_token');
+  const challengeResponse = optionalString(args, 'challenge_response');
+
+  if (!cycle.active) {
+    // S10: slot já fechado. Distinguir retorno duplicado já aplicado (idempotente
+    // reconhecível) de payload sem nenhum slot conhecido. NUNCA reabrir o ciclo.
+    // Um complete já aplicado para este run_id aparece no history como evento
+    // `action: 'complete'`/`status: 'passed'` com o mesmo validator_run_id.
+    const appliedCompleteEvent = cycle.history.find(
+      (event) =>
+        event.action === 'complete' &&
+        event.status === 'passed' &&
+        event.validator_run_id === activeValidatorRunId,
+    );
+    if (appliedCompleteEvent) {
+      return {
+        gate: 'G4',
+        action: 'complete',
+        status: 'blocked',
+        timestamp,
+        validator_run_id: activeValidatorRunId,
+        state_path: statePathValue,
+        stale_discarded: true,
+        reason: 'stale_duplicate_already_applied',
+        last_verdict: cycle.last_verdict,
+        // S10/P3-2: ecoa o veredito real que o complete casado produziu no history
+        // (repair_required, passed, passed_with_observations,
+        // blocked_final_validator_failed). last_verdict reflete só o ciclo atual e
+        // pode divergir do estado real daquele evento — applied_validator_status
+        // evita que o consumidor leia um fail→repair como conclusão bem-sucedida.
+        applied_validator_status: appliedCompleteEvent.validator_status ?? null,
+        error: `Retorno duplicado do validator já aplicado (run_id ${activeValidatorRunId}); descartado de forma idempotente`,
+        next_action: 'descartar_retorno_duplicado_idempotente',
+      };
+    }
+    return {
+      gate: 'G4',
+      action: 'complete',
+      status: 'blocked',
+      timestamp,
+      stale_discarded: true,
+      error: 'Nenhum validator ativo para concluir',
+      next_action: 'start_validator_primeiro',
+    };
+  }
+
+  if (cycle.active.run_id !== activeValidatorRunId) {
+    return {
+      gate: 'G4',
+      action: 'complete',
+      status: 'blocked',
+      timestamp,
+      validator_attempt: cycle.active.attempt,
+      validator_run_id: activeValidatorRunId,
+      stale_discarded: true,
+      error: `validator_run_id não corresponde ao validator ativo: recebido ${activeValidatorRunId}`,
+      next_action: 'aguardar_ou_descartar_retorno_stale_do_validator',
+    };
+  }
+
+  if (cycle.active.state_path !== statePathValue) {
+    return {
+      gate: 'G4',
+      action: 'complete',
+      status: 'blocked',
+      timestamp,
+      validator_attempt: cycle.active.attempt,
+      validator_run_id: activeValidatorRunId,
+      state_path: statePathValue,
+      stale_discarded: true,
+      error: `state_path do validator ativo diverge: esperado ${cycle.active.state_path}, recebido ${statePathValue}`,
+      next_action: 'corrigir_payload_do_validator',
+    };
+  }
+
+  if (dispatchToken === undefined) {
+    return {
+      gate: 'G4',
+      action: 'complete',
+      status: 'blocked',
+      timestamp,
+      validator_attempt: cycle.active.attempt,
+      validator_run_id: activeValidatorRunId,
+      state_path: statePathValue,
+      stale_discarded: true,
+      error: 'dispatch_token obrigatório para concluir validator ativo',
+      next_action: 'reler_validator_recovery_e_reenviar_token',
+    };
+  }
+
+  // S04: verificação idempotente do token de dispatch (anti-stale).
+  // Divergência → blocked SEM fechar o slot (não retorna validator_cycle, então
+  // active é preservado pelo merge).
+  // S10: marca stale_discarded para o orquestrador distinguir stale de erro real.
+  if (cycle.active.dispatch_token !== dispatchToken) {
+    return {
+      gate: 'G4',
+      action: 'complete',
+      status: 'blocked',
+      timestamp,
+      validator_attempt: cycle.active.attempt,
+      validator_run_id: activeValidatorRunId,
+      state_path: statePathValue,
+      stale_discarded: true,
+      error: `token de dispatch divergente: esperado ${cycle.active.dispatch_token}, recebido ${dispatchToken}`,
+      next_action: 'aguardar_ou_descartar_retorno_stale_do_validator',
+    };
+  }
+
+  // P1.1: proof-of-work. Só vale se o start emitiu challenge (cycle.active.challenge).
+  // Falha (resposta ausente/hash divergente) NÃO fecha o slot — igual stale: active é
+  // preservado (não retornamos validator_cycle), o orquestrador re-despacha o MESMO
+  // validador (mesmo attempt) que lê o boundary e reenvia o hash correto. Não consome
+  // attempt nem reabre terminal. `unverifiable` (arquivo sumiu no complete) não bloqueia.
+  const challengeCheck = verifyValidatorChallenge(cycle.active.challenge, challengeResponse, args);
+  if (!challengeCheck.ok) {
+    // P2-1: falhas de challenge são bounded por attempt. As anteriores ficam no
+    // history (patchValidatorResult registra cada challenge_failed). Esgotado o
+    // teto, o slot fecha terminal (fail-closed) em vez de re-despachar pra sempre.
+    const priorChallengeFailures = cycle.history.filter(
+      (event) =>
+        event.action === 'complete' &&
+        event.validator_status === 'challenge_failed' &&
+        event.validator_run_id === activeValidatorRunId,
+    ).length;
+    if (priorChallengeFailures >= VALIDATOR_CHALLENGE_MAX_FAILURES) {
+      return {
+        gate: 'G4',
+        action: 'complete',
+        status: 'blocked',
+        timestamp,
+        validator_attempt: cycle.active.attempt,
+        validator_run_id: activeValidatorRunId,
+        state_path: statePathValue,
+        validator_status: 'challenge_exhausted',
+        challenge_file: cycle.active.challenge.file,
+        error: `Proof-of-work do validador falhou ${priorChallengeFailures + 1}x (máximo=${VALIDATOR_CHALLENGE_MAX_FAILURES}) para ${cycle.active.challenge.file}; re-dispatch encerrado`,
+        cause: 'validator_proof_of_work_exhausted',
+        impact: 'validador_nao_comprovou_leitura_do_boundary_apos_teto_de_tentativas',
+        next_action: 'encerrar_com_blocked_e_investigar_resolucao_de_path_do_challenge_no_host',
+        banner: renderBanner('validacao', { status: 'blocked_challenge_exhausted' }),
+        validator_cycle: {
+          dispatch_token: cycle.dispatch_token,
+          status: 'blocked',
+          active: null,
+          last_state_path: statePathValue,
+          last_verdict: cycle.last_verdict,
+          findings_packet: cycle.findings_packet,
+          repair: cycle.repair,
+        },
+      };
+    }
+    return {
+      gate: 'G4',
+      action: 'complete',
+      status: 'blocked',
+      timestamp,
+      validator_attempt: cycle.active.attempt,
+      validator_run_id: activeValidatorRunId,
+      state_path: statePathValue,
+      validator_status: 'challenge_failed',
+      challenge_file: cycle.active.challenge.file,
+      challenge_failures: priorChallengeFailures + 1,
+      challenge_failures_max: VALIDATOR_CHALLENGE_MAX_FAILURES,
+      error: `Proof-of-work do validador falhou (${challengeCheck.reason}): o veredito não comprovou leitura de ${cycle.active.challenge.file}`,
+      cause: 'validator_proof_of_work_failed',
+      impact: 'sem_prova_de_leitura_do_boundary_o_veredito_pode_nao_ter_lido_o_codigo',
+      next_action: 'redespachar_o_mesmo_validador_irmao_que_le_o_boundary_e_reenvia_challenge_response',
+    };
+  }
+  const challengeVerified = !cycle.active.challenge
+    ? 'no_challenge'
+    : challengeCheck.unverifiable ? 'unverifiable' : 'verified';
+
+  const normalizedVerdict = verdict === 'pass'
+    ? 'passed'
+    : verdict === 'pass_with_observations'
+      ? 'passed_with_observations'
+      : verdict;
+
+  if (VALIDATOR_PASSED_STATUSES.has(normalizedVerdict)) {
+    return {
+      gate: 'G4',
+      action: 'complete',
+      status: 'passed',
+      timestamp,
+      validator_attempt: cycle.active.attempt,
+      validator_run_id: activeValidatorRunId,
+      state_path: statePathValue,
+      validator_status: normalizedVerdict,
+      challenge_verified: challengeVerified,
+      next_action: 'complete_plan_execute',
+      banner: renderBanner('validacao', { status: normalizedVerdict }),
+      validator_cycle: {
+        dispatch_token: cycle.dispatch_token,
+        status: normalizedVerdict,
+        active: null,
+        last_state_path: statePathValue,
+        last_verdict: normalizedVerdict,
+        findings_packet: packet ?? null,
+        repair: {
+          skill: WORKFLOW_CONFIG.skills.findings_repair,
+          status: cycle.repair.status === 'completed' ? 'completed' : 'not_needed',
+          required_from_attempt: cycle.repair.required_from_attempt,
+          requested_at: cycle.repair.requested_at,
+          completed_at: cycle.repair.completed_at,
+          active: null,
+        },
+      },
+    };
+  }
+
+  if (normalizedVerdict !== 'fail') {
+    return {
+      gate: 'G4',
+      action: 'complete',
+      status: 'blocked',
+      timestamp,
+      error: `Veredito inválido do validator: ${verdict}`,
+      validator_attempt: cycle.active.attempt,
+      next_action: 'corrigir_output_do_validator',
+    };
+  }
+
+  if (cycle.active.attempt >= cycle.max_attempts) {
+    return {
+      gate: 'G4',
+      action: 'complete',
+      status: 'blocked',
+      timestamp,
+      validator_attempt: cycle.active.attempt,
+      validator_run_id: activeValidatorRunId,
+      state_path: statePathValue,
+      validator_status: 'blocked_final_validator_failed',
+      challenge_verified: challengeVerified,
+      error: `Segundo validator falhou; terceiro validator é proibido (máximo=${cycle.max_attempts})`,
+      next_action: 'encerrar_com_blocked_final_validator_failed',
+      banner: renderBanner('validacao', { status: 'blocked_final_validator_failed' }),
+      validator_cycle: {
+        dispatch_token: cycle.dispatch_token,
+        status: 'blocked',
+        active: null,
+        last_state_path: statePathValue,
+        last_verdict: 'fail',
+        findings_packet: packet ?? null,
+        repair: {
+          skill: WORKFLOW_CONFIG.skills.findings_repair,
+          status: 'exhausted',
+          required_from_attempt: cycle.active.attempt,
+          requested_at: cycle.repair.requested_at,
+          completed_at: cycle.repair.completed_at,
+          active: null,
+        },
+      },
+    };
+  }
+
+  return {
+    gate: 'G4',
+    action: 'complete',
+    status: 'passed',
+    timestamp,
+    validator_attempt: cycle.active.attempt,
+    validator_run_id: activeValidatorRunId,
+    state_path: statePathValue,
+    validator_status: 'repair_required',
+    challenge_verified: challengeVerified,
+    next_action: 'start_findings_repair_lock',
+    banner: renderBanner('validacao', { status: 'repair_required' }),
+    validator_cycle: {
+      dispatch_token: cycle.dispatch_token,
+      status: 'repair_required',
+      active: null,
+      last_state_path: statePathValue,
+      last_verdict: 'fail',
+      findings_packet: packet ?? null,
+      repair: {
+        skill: WORKFLOW_CONFIG.skills.findings_repair,
+        status: 'required',
+        required_from_attempt: cycle.active.attempt,
+        requested_at: timestamp,
+        completed_at: null,
+        active: null,
+      },
+    },
+  };
+}
+
+function validatorRepairStart(args, context) {
+  const runId = validateRunId(args.run_id);
+  const timestamp = nowIso();
+  const cycle = normalizeValidatorCycle(context.state.data?.validator_cycle ?? {});
+  const statePathValue = requiredString(args, 'state_path');
+
+  if (cycle.active) {
+    return {
+      gate: 'G4',
+      action: 'repair_start',
+      status: 'blocked',
+      timestamp,
+      error: 'Repair não pode iniciar enquanto há validator ativo',
+      validator_attempt: cycle.active.attempt,
+      next_action: 'aguardar_validator_ativo',
+    };
+  }
+
+  if (cycle.repair.active) {
+    return {
+      gate: 'G4',
+      action: 'repair_start',
+      status: 'blocked',
+      timestamp,
+      validator_attempt: cycle.attempts_used,
+      repair_run_id: cycle.repair.active.run_id ?? null,
+      error: `Repair já está ativo para attempt ${cycle.attempts_used}`,
+      next_action: 'aguardar_findings_repair_ativo',
+    };
+  }
+
+  if (cycle.status !== 'repair_required') {
+    return {
+      gate: 'G4',
+      action: 'repair_start',
+      status: 'blocked',
+      timestamp,
+      error: `Repair fora de ordem: status atual ${cycle.status}`,
+      next_action: 'completar_validator_fail_antes_do_repair',
+    };
+  }
+
+  if (cycle.last_state_path && cycle.last_state_path !== statePathValue) {
+    return {
+      gate: 'G4',
+      action: 'repair_start',
+      status: 'blocked',
+      timestamp,
+      validator_attempt: cycle.attempts_used,
+      state_path: statePathValue,
+      error: `Repair deve partir do state_path do fail: esperado ${cycle.last_state_path}, recebido ${statePathValue}`,
+      next_action: 'corrigir_state_path_do_repair',
+    };
+  }
+
+  const activeRepairRunId = repairRunId(runId, cycle.attempts_used, timestamp);
+  return {
+    gate: 'G4',
+    action: 'repair_start',
+    status: 'passed',
+    timestamp,
+    validator_attempt: cycle.attempts_used,
+    repair_run_id: activeRepairRunId,
+    repair_budget: 1,
+    state_path: statePathValue,
+    validator_status: 'repair_running',
+    next_action: `dispatch_${WORKFLOW_CONFIG.skills.findings_repair}`,
+    banner: renderBanner('validacao', { status: 'repair_running' }),
+    validator_cycle: {
+      status: 'repair_running',
+      repair: {
+        skill: WORKFLOW_CONFIG.skills.findings_repair,
+        status: 'running',
+        required_from_attempt: cycle.repair.required_from_attempt ?? cycle.attempts_used,
+        requested_at: cycle.repair.requested_at ?? timestamp,
+        completed_at: null,
+        active: {
+          run_id: activeRepairRunId,
+          state_path: statePathValue,
+          started_at: timestamp,
+        },
+      },
+    },
+  };
+}
+
+function validatorRepairComplete(args, context) {
+  const timestamp = nowIso();
+  const cycle = normalizeValidatorCycle(context.state.data?.validator_cycle ?? {});
+  const statePathValue = requiredString(args, 'state_path');
+  const activeRepairRunId = requiredString(args, 'repair_run_id');
+
+  if (cycle.active) {
+    return {
+      gate: 'G4',
+      action: 'repair_complete',
+      status: 'blocked',
+      timestamp,
+      error: 'Repair não pode fechar enquanto há validator ativo',
+      validator_attempt: cycle.active.attempt,
+      next_action: 'aguardar_validator_ativo',
+    };
+  }
+
+  // S10: idempotência reconhecível — um repair_complete já aplicado para este
+  // repair_run_id aparece no history como evento `repair_complete`/`passed`.
+  // Distingue duplicado/fora de ordem após repair concluído de erro real.
+  const appliedRepairEvent = cycle.history.find(
+    (event) =>
+      event.action === 'repair_complete' &&
+      event.status === 'passed' &&
+      event.repair_run_id === activeRepairRunId,
+  );
+
+  if (cycle.status !== 'repair_running') {
+    return {
+      gate: 'G4',
+      action: 'repair_complete',
+      status: 'blocked',
+      timestamp,
+      repair_run_id: activeRepairRunId,
+      stale_discarded: true,
+      ...(appliedRepairEvent ? { reason: 'repair_duplicate_already_applied' } : {}),
+      error: appliedRepairEvent
+        ? `Repair duplicado já aplicado (run_id ${activeRepairRunId}); descartado de forma idempotente`
+        : `Repair fora de ordem: status atual ${cycle.status}`,
+      next_action: appliedRepairEvent
+        ? 'descartar_retorno_duplicado_idempotente'
+        : 'iniciar_findings_repair_antes_de_concluir',
+    };
+  }
+
+  if (!cycle.repair.active) {
+    return {
+      gate: 'G4',
+      action: 'repair_complete',
+      status: 'blocked',
+      timestamp,
+      repair_run_id: activeRepairRunId,
+      stale_discarded: true,
+      ...(appliedRepairEvent ? { reason: 'repair_duplicate_already_applied' } : {}),
+      error: appliedRepairEvent
+        ? `Repair duplicado já aplicado (run_id ${activeRepairRunId}); descartado de forma idempotente`
+        : 'Nenhum repair ativo para concluir',
+      next_action: appliedRepairEvent
+        ? 'descartar_retorno_duplicado_idempotente'
+        : 'start_findings_repair_primeiro',
+    };
+  }
+
+  if (cycle.repair.active.run_id !== activeRepairRunId) {
+    return {
+      gate: 'G4',
+      action: 'repair_complete',
+      status: 'blocked',
+      timestamp,
+      validator_attempt: cycle.attempts_used,
+      repair_run_id: activeRepairRunId,
+      stale_discarded: true,
+      ...(appliedRepairEvent ? { reason: 'repair_duplicate_already_applied' } : {}),
+      error: `repair_run_id não corresponde ao repair ativo: recebido ${activeRepairRunId}`,
+      next_action: 'aguardar_ou_descartar_retorno_stale_do_repair',
+    };
+  }
+
+  if (cycle.repair.active.state_path !== statePathValue) {
+    return {
+      gate: 'G4',
+      action: 'repair_complete',
+      status: 'blocked',
+      timestamp,
+      validator_attempt: cycle.attempts_used,
+      repair_run_id: activeRepairRunId,
+      state_path: statePathValue,
+      stale_discarded: true,
+      error: `state_path do repair ativo diverge: esperado ${cycle.repair.active.state_path}, recebido ${statePathValue}`,
+      next_action: 'atualizar_o_state_path_original_sem_redirecionar_boundary',
+    };
+  }
+
+  return {
+    gate: 'G4',
+    action: 'repair_complete',
+    status: 'passed',
+    timestamp,
+    validator_attempt: cycle.attempts_used,
+    repair_run_id: activeRepairRunId,
+    validator_status: 'ready_for_retry',
+    state_path: statePathValue,
+    next_action: 'dispatch_task_validator_retry',
+    banner: renderBanner('validacao', { status: 'ready_for_retry' }),
+    validator_cycle: {
+      status: 'ready_for_retry',
+      active: null,
+      last_state_path: statePathValue,
+      repair: {
+        skill: WORKFLOW_CONFIG.skills.findings_repair,
+        status: 'completed',
+        required_from_attempt: cycle.repair.required_from_attempt ?? cycle.attempts_used,
+        requested_at: cycle.repair.requested_at,
+        completed_at: timestamp,
+        active: null,
+      },
+    },
+  };
+}
+
+function lockValidator(args = {}) {
+  const runId = validateRunId(args.run_id);
+  const action = args.action ?? 'start';
+  if (!['start', 'complete', 'repair_start', 'repair_complete'].includes(action)) {
+    throw rpcError(-32602, `Ação inválida para atlas_lock_validator: ${action}`);
+  }
+  const context = getDispatchState(runId, args);
+  const result = action === 'start'
+    ? validatorStart(args, context)
+    : action === 'complete'
+      ? validatorComplete(args, context)
+      : action === 'repair_start'
+        ? validatorRepairStart(args, context)
+        : validatorRepairComplete(args, context);
+  patchValidatorResult(runId, result, args);
+  return result;
+}
+
+// Banner canônico do lock_dispatch (T07): mapeia (fase, status) ao evento do
+// banco. Fase de execução → `exec`/`validação`; review → `review`; conclusão de
+// plano → `plano`; bloqueio → `preflight_fail` (BLOCK genérico com motivo).
+// Tabela data-driven; nenhuma string de banner montada inline no gate.
+function dispatchBanner(result) {
+  if (result.status === 'blocked') {
+    const motivo = result.error ? String(result.error).slice(0, 80) : `${result.phase} bloqueado`;
+    return renderBanner('preflight_fail', { motivo });
+  }
+  if (result.phase === 'slice_review') {
+    return renderBanner('review', { status: result.action === 'complete' ? 'ok' : 'iniciado' });
+  }
+  if (result.phase === 'plan_execute') {
+    // complete carrega validator_status → evento de validação; start → exec da slice.
+    return result.action === 'complete'
+      ? renderBanner('validacao', { status: result.validator_status ?? 'ok' })
+      : renderBanner('exec', { i: 1, n: 1 });
+  }
+  if (result.phase === 'plan_handoff') {
+    return renderBanner('plano', {});
+  }
+  // demais fases (prd_interview etc.): exec genérico da fase em andamento.
+  return renderBanner('exec', { i: 1, n: 1 });
+}
+
+function assertAfterPlan(args = {}) {
+  const runId = validateRunId(args.run_id);
+  const attemptedAction = requiredString(args, 'attempted_action');
+  const { routing, dispatch } = getDispatchState(runId, args);
+  const timestamp = nowIso();
+  let result;
+
+  if (routing.mode === 'execute') {
+    // PRD D13: o gate de bloqueio pós-plano é próprio do full e NÃO se aplica a
+    // execute — o plano já é o input inicial. Aqui não se exige fase de plano;
+    // o equivalente é a re-verificação do plano antes de despachar a execução.
+    result = {
+      gate: 'G11',
+      action: 'assert_after_plan',
+      phase: 'after_plan',
+      status: 'passed',
+      mode: 'execute',
+      applicable: false,
+      timestamp,
+      current_phase: dispatch.previous_phase ?? null,
+      expected_phase: 'plan_execute',
+      note: 'assert_after_plan não se aplica em execute (PRD D13): plano é o input; re-verifique o plano antes do dispatch.',
+      next_action: 'reverificar_plano_e_dispatch_plan_execute',
+    };
+  } else if (routing.mode === 'full' && dispatch.plan_validated && !dispatch.execution_completed) {
+    if (attemptedAction === 'dispatch_plan_execute') {
+      result = {
+        gate: 'G11',
+        action: 'assert_after_plan',
+        phase: 'after_plan',
+        status: 'passed',
+        timestamp,
+        current_phase: dispatch.previous_phase ?? null,
+        expected_phase: 'plan_execute',
+        next_action: 'dispatch_plan_execute_blocking',
+      };
+    } else {
+      result = {
+        gate: 'G11',
+        action: 'assert_after_plan',
+        phase: 'after_plan',
+        status: 'blocked',
+        // block_kind diferencia "gate funcionando" de "erro de pipeline": este bloqueio é
+        // o guard de conclusão prematura disparando como projetado (S3). Não é falha do
+        // MCP nem estado corrompido — a ação correta é despachar plan_execute e seguir.
+        block_kind: 'premature_completion_guard',
+        timestamp,
+        error: `Conclusão prematura bloqueada no full: ${attemptedAction}`,
+        note: 'Gate G11 funcionando: o full não conclui só com handoff. Não é erro de pipeline — despache plan_execute (blocking) e prossiga.',
+        current_phase: dispatch.previous_phase ?? null,
+        expected_phase: 'plan_execute',
+        next_action: 'dispatch_plan_execute_blocking',
+      };
+    }
+  } else {
+    result = {
+      gate: 'G11',
+      action: 'assert_after_plan',
+      phase: 'after_plan',
+      status: 'passed',
+      timestamp,
+      current_phase: dispatch.previous_phase ?? null,
+      expected_phase: dispatch.next_phase ?? null,
+      next_action: dispatch.next_action ?? 'avançar',
+    };
+  }
+
+  // Banner canônico do assert_after_plan (T07): pós-plano coerente com o evento
+  // `plano` (plano validado / re-verificação) quando passa; BLOCK com motivo quando
+  // bloqueia. Fonte única no banco BANNER_TEMPLATES.
+  result.banner = result.status === 'blocked'
+    ? renderBanner('preflight_fail', { motivo: result.error ? String(result.error).slice(0, 80) : 'pós-plano bloqueado' })
+    : renderBanner('plano', {});
+
+  patchDispatchResult(runId, result, args);
+  return result;
+}
+
+function toolResult(value) {
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(value, null, 2),
+      },
+    ],
+  };
+}
+
+function toolsList() {
+  return {
+    tools: [
+      {
+        name: 'atlas_ping',
+        description: 'Retorna saúde, identidade, versão e capacidades mínimas do MCP Atlas Workflow.',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {},
+        },
+      },
+      {
+        name: 'atlas_capabilities',
+        description: 'Adapter de host: detecta o host (Claude/Codex/genérico) e retorna descritores canônicos de disparo de subagente, todo nativo e paths de plano. Skills consultam isto em vez de hardcodar nome de host.',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            host: { type: 'string', enum: HOST_NAMES },
+          },
+        },
+      },
+      {
+        name: 'atlas_run_state',
+        description: 'Cria, atualiza ou consulta estado de run em .atlas/state/ no cwd do projeto consumidor.',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['run_id'],
+          properties: {
+            action: { type: 'string', enum: ['get', 'upsert'], default: 'get' },
+            run_id: { type: 'string', minLength: 1 },
+            project_root: { type: 'string', minLength: 1 },
+            phase: { type: 'string' },
+            status: { type: 'string' },
+            summary: { type: 'string' },
+            data: { type: 'object' },
+          },
+        },
+      },
+      {
+        name: 'atlas_verify_artifact',
+        description: 'Gate G1: verifica se artefato obrigatório existe em disco e é legível.',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['run_id', 'artifact_path'],
+          properties: {
+            run_id: { type: 'string', minLength: 1 },
+            project_root: { type: 'string', minLength: 1 },
+            artifact_path: { type: 'string', minLength: 1 },
+            artifact_kind: { enum: ['prd', 'plan'] },
+          },
+        },
+      },
+      {
+        name: 'atlas_scan_prd',
+        description: 'Gate G5: escaneia PRD por padrões determinísticos de ambiguidade bloqueante.',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['run_id', 'prd_path'],
+          properties: {
+            run_id: { type: 'string', minLength: 1 },
+            project_root: { type: 'string', minLength: 1 },
+            prd_path: { type: 'string', minLength: 1 },
+          },
+        },
+      },
+      {
+        name: 'atlas_verify_template_conformance',
+        description: 'Gate de conformidade: valida PRD ou plano contra o template canônico aplicável e registra pendências acionáveis.',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['run_id', 'artifact_path', 'artifact_type'],
+          properties: {
+            run_id: { type: 'string', minLength: 1 },
+            project_root: { type: 'string', minLength: 1 },
+            artifact_path: { type: 'string', minLength: 1 },
+            artifact_type: { type: 'string', enum: ['prd', 'plan'] },
+            required_status: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'atlas_classify_input',
+        description: 'Classifica o input em backlog|prd|plan|unknown (PRD D4/D5). Verdade forte = conformidade de template de plano passa; depois cabeçalho canônico; nome PLAN_*.md é só dica fraca. Devolve artifact_type + banner de roteamento. Alimenta o guardrail anti plano-de-plano.',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['run_id', 'input_path'],
+          properties: {
+            run_id: { type: 'string', minLength: 1 },
+            project_root: { type: 'string', minLength: 1 },
+            input_path: { type: 'string', minLength: 1 },
+          },
+        },
+      },
+      {
+        name: 'atlas_preflight',
+        description: 'Gate PREREQ+G10: hard-fail de pré-requisitos de determinismo (subagente/MCP do host, DEC-004), depois valida modo, versão e lock ativo, travando a rota da run. Output declara guarantee_level (enum full_pipeline|reduced_standalone).',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['run_id', 'mode'],
+          properties: {
+            run_id: { type: 'string', minLength: 1 },
+            project_root: { type: 'string', minLength: 1 },
+            mode: { type: 'string', enum: WORKFLOW_CONFIG.modes },
+            expected_version: { type: 'string' },
+            host: { type: 'string', enum: HOST_NAMES },
+            // additionalProperties:false é enforçado pelo client MCP; o servidor ainda
+            // delimita defensivamente o override a PREREQUISITE_FLAGS em checkPrerequisites.
+            host_capabilities: {
+              type: 'object',
+              description: 'Disponibilidade real reportada pelo host (override das flags do perfil). Ex.: pi sem deps → {"subagent_available":false}.',
+              additionalProperties: false,
+              properties: {
+                subagent_available: { type: 'boolean' },
+                mcp_available: { type: 'boolean' },
+                todo_available: { type: 'boolean' },
+                // Gate JOIN separado (DEC-SIB-003): report afirmativo de join síncrono
+                // para hosts must_report (pi/generic). NÃO entra em PREREQUISITE_FLAGS.
+                join_sync_available: { type: 'boolean' },
+              },
+            },
+          },
+        },
+      },
+      {
+        name: 'atlas_lock_dispatch',
+        description: 'Gates G7/G8: controla fase ativa, transições de dispatch, validator antes de review e concorrência 1.',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['run_id', 'phase'],
+          properties: {
+            run_id: { type: 'string', minLength: 1 },
+            project_root: { type: 'string', minLength: 1 },
+            action: { type: 'string', enum: ['start', 'complete', 'abort'], default: 'start' },
+            phase: { type: 'string', enum: ['plan_handoff', 'plan_execute', 'slice_review'] },
+            validator_status: { type: 'string' },
+          },
+        },
+      },
+      {
+        name: 'atlas_lock_validator',
+        description: 'Gate G4/G8 sibling: enforça um validator por vez em todos os hosts, dispatch_token obrigatório no retorno, proof-of-work (challenge sha256 do boundary recomputado no complete), máximo de 2 attempts, repair obrigatório entre fail e retry e bloqueio explícito do terceiro validator.',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['run_id', 'action'],
+          properties: {
+            run_id: { type: 'string', minLength: 1 },
+            project_root: { type: 'string', minLength: 1 },
+            action: { type: 'string', enum: ['start', 'complete', 'repair_start', 'repair_complete'] },
+            state_path: { type: 'string' },
+            validator_run_id: { type: 'string' },
+            repair_run_id: { type: 'string' },
+            dispatch_token: { type: 'integer' },
+            challenge_response: { type: 'string' },
+            verdict: { type: 'string', enum: ['pass', 'pass_with_observations', 'fail'] },
+            data: { type: 'object', additionalProperties: true },
+            host: { type: 'string', enum: HOST_NAMES },
+          },
+        },
+      },
+      {
+        name: 'atlas_assert_after_plan',
+        description: 'Gate G11: bloqueia encerramento prematuro do modo full após plano validado e antes da execução.',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['run_id', 'attempted_action'],
+          properties: {
+            run_id: { type: 'string', minLength: 1 },
+            project_root: { type: 'string', minLength: 1 },
+            attempted_action: { type: 'string' },
+          },
+        },
+      },
+    ],
+  };
+}
+
+function handleRequest(message) {
+  const { id, method, params = {} } = message;
+  if (method === 'initialize') {
+    return {
+      id,
+      result: {
+        protocolVersion: params.protocolVersion ?? '2024-11-05',
+        serverInfo: { name: SERVER_NAME, version: readVersion() },
+        capabilities: { tools: {} },
+      },
+    };
+  }
+  if (method === 'tools/list') return { id, result: toolsList() };
+  if (method === 'tools/call') {
+    const name = params.name;
+    const args = params.arguments ?? {};
+    try {
+      const value =
+        name === 'atlas_ping' ? ping() :
+        name === 'atlas_capabilities' ? capabilities(args) :
+        name === 'atlas_run_state' ? runState(args) :
+        name === 'atlas_verify_artifact' ? verifyArtifact(args) :
+        name === 'atlas_scan_prd' ? scanPrd(args) :
+        name === 'atlas_verify_template_conformance' ? verifyTemplateConformance(args) :
+        name === 'atlas_classify_input' ? classifyInput(args) :
+        name === 'atlas_preflight' ? preflight(args) :
+        name === 'atlas_lock_dispatch' ? lockDispatch(args) :
+        name === 'atlas_lock_validator' ? lockValidator(args) :
+        name === 'atlas_assert_after_plan' ? assertAfterPlan(args) :
+        (() => { throw rpcError(-32601, `Tool desconhecida: ${name}`); })();
+      logCall({ tool: name, run: args.run_id ?? null, status: 'ok' }, args);
+      return { id, result: toolResult(value) };
+    } catch (error) {
+      logCall({ tool: name, run: args.run_id ?? null, status: 'error', error: error.message }, args);
+      throw error;
+    }
+  }
+  if (method === 'notifications/initialized') return null;
+  throw rpcError(-32601, `Método desconhecido: ${method}`);
+}
+
+function send(message) {
+  if (message === null || message.id === undefined) return;
+  const body = JSON.stringify({ jsonrpc: '2.0', ...message });
+  process.stdout.write(`${body}\n`);
+}
+
+function parseMessages(buffer) {
+  const messages = [];
+  let rest = buffer;
+
+  while (true) {
+    const crlfHeaderEnd = rest.indexOf('\r\n\r\n');
+    const lfHeaderEnd = rest.indexOf('\n\n');
+    const hasCrlfHeader = crlfHeaderEnd !== -1 && (lfHeaderEnd === -1 || crlfHeaderEnd <= lfHeaderEnd);
+    const headerEnd = hasCrlfHeader ? crlfHeaderEnd : lfHeaderEnd;
+    if (headerEnd === -1) break;
+    const header = rest.slice(0, headerEnd);
+    const match = /^Content-Length:\s*(\d+)$/im.exec(header);
+    if (!match) break;
+    const length = Number(match[1]);
+    const bodyStart = headerEnd + (hasCrlfHeader ? 4 : 2);
+    const bodyEnd = bodyStart + length;
+    if (rest.length < bodyEnd) return { messages, rest };
+    messages.push(JSON.parse(rest.slice(bodyStart, bodyEnd)));
+    rest = rest.slice(bodyEnd);
+  }
+
+  if (messages.length === 0 && /^Content-Length:/i.test(rest) && !/\r?\n\r?\n/.test(rest)) {
+    return { messages, rest };
+  }
+
+  if (messages.length === 0 && rest.includes('\n')) {
+    const lines = rest.split(/\r?\n/);
+    rest = lines.pop() ?? '';
+    for (const line of lines) {
+      if (line.trim()) messages.push(JSON.parse(line));
+    }
+  }
+
+  return { messages, rest };
+}
+
+function startStdioLoop() {
+  let pending = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => {
+    try {
+      const parsed = parseMessages(pending + chunk);
+      pending = parsed.rest;
+      for (const message of parsed.messages) {
+        try {
+          send(handleRequest(message));
+        } catch (error) {
+          send({
+            id: message.id,
+            error: {
+              code: error.code ?? -32000,
+              message: error.message,
+              data: error.data,
+            },
+          });
+        }
+      }
+    } catch (error) {
+      send({ id: null, error: { code: -32700, message: `JSON inválido: ${error.message}` } });
+    }
+  });
+}
+
+// Só inicia o loop stdio quando executado como entrypoint (node server.js).
+// Importado por testes (node --test), o módulo expõe funções puras sem bootar I/O.
+const isEntrypoint = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isEntrypoint) startStdioLoop();
+
+export {
+  HOST_ADAPTERS,
+  HOST_NAMES,
+  PREREQUISITES,
+  CAPABILITIES_SCHEMA_VERSION,
+  WORKFLOW_CONFIG,
+  GUARANTEE_LEVELS,
+  detectHost,
+  capabilities,
+  checkPrerequisites,
+  checkJoinCapability,
+  expectedNextPhase,
+  guaranteeLevelForMode,
+  classifyArtifactContent,
+  BANNER_TEMPLATES,
+  BANNER_EVENTS,
+  renderBanner,
+  verifyArtifact,
+  scanPrd,
+  verifyTemplateConformance,
+  classifyInput,
+  preflight,
+  lockDispatch,
+  lockValidator,
+  assertAfterPlan,
+  runState,
+  ping,
+  toolsList,
+};