atlas-workflow 0.9.2 → 0.9.3

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

@@ -283,23 +283,81 @@ const HOST_ADAPTERS = {
   },
   antigravity: {
     label: 'Antigravity',
+    // Antigravity não tem skill loader nativo em subagentes — o SKILL.md completo
+    // DEVE ser embutido no Prompt de cada invoke_subagent (via define_subagent como
+    // system_prompt ou diretamente no Prompt). Nunca despachar subagente sem SKILL.md
+    // injetado, pois o subagente não carregará o contrato e o pipeline vai impasse.
+    //
+    // Fluxo para fases de execução/validação (executor, validator, repair, review):
+    //   1. define_subagent(name: "<atlas-exec>", system_prompt: "<SKILL.MD completo>")
+    //   2. invoke_subagent(Subagents: [{TypeName: "<atlas-exec>", Role: "<papel>",
+    //                                   Prompt: "<state_path ou plan_path>",
+    //                                   Workspace: "branch"}])
+    //   — invoke_subagent é BLOQUEANTE por design: não polling, não background.
+    //   — Workspace: "branch" garante isolamento de contexto (fronteira G4/G9).
+    //
+    // Fases documentais (PRD, entrevista, plano) NÃO usam subagente — o orquestrador
+    // conduz no fio principal; define_subagent não é chamado para essas fases.
     subagent_dispatch: {
-      mechanism: 'define_subagent(name, system_prompt) + invoke_subagent(Subagents)',
-      example: 'define_subagent(name: "atlas-task-validator", system_prompt: "<SKILL_MD>") e invoke_subagent(Subagents: [{TypeName: "atlas-task-validator", Role: "Validator", Prompt: "<state_path>"}])',
-      registration: 'Mapeamento de skills e agents via define_subagent dinâmico',
+      mechanism: 'define_subagent(name, system_prompt) + invoke_subagent(Subagents: [{TypeName, Role, Prompt, Workspace}])',
+      example: 'define_subagent(name: "atlas-task-validator", system_prompt: "<SKILL.MD completo do atlas-task-validator>") seguido de invoke_subagent(Subagents: [{TypeName: "atlas-task-validator", Role: "Validador frio", Prompt: "<state_path>", Workspace: "branch"}])',
+      registration: 'define_subagent dinâmico por sessão — o SKILL.md canônico é passado como system_prompt; sem pré-registro persistente',
+      // Sem loader nativo: o SKILL.md DEVE ser embutido no system_prompt do define_subagent.
+      // Não usar TypeName: "self" sem injetar o SKILL.md — o subagente herdaria o contexto
+      // do orquestrador e violaria o isolamento frio (G4/G9).
+      skill_loading: 'embed_in_system_prompt',
     },
     validator_dispatch: {
       dispatcher: 'orchestrator',
       join: {
         sync: 'self_evident',
         confidence: 'high',
-        mechanism: 'invoke_subagent bloqueante por design do host',
+        mechanism: 'invoke_subagent bloqueante por design do host — sem polling, sem callback',
       },
     },
-    question_prompt: { mechanism: 'notify_user', mode: 'structured', max_questions: 4, options_per_question: 3, persistence: 'prd_after_each_round' },
+    // question_prompt: usado pela atlas-prd-interview para fazer perguntas ao usuário.
+    // No Antigravity, usar ask_question (ferramenta nativa de perguntas interativas).
+    // IMPORTANTE — resume_after_interview: após receber respostas via ask_question,
+    // persistir no PRD e RETOMAR O PIPELINE IMEDIATAMENTE sem nova confirmação.
+    // Nunca aguardar input adicional do usuário entre fases — viola fire-and-continue.
+    question_prompt: {
+      mechanism: 'ask_question',
+      mode: 'structured',
+      max_questions: 4,
+      options_per_question: 3,
+      persistence: 'prd_after_each_round',
+      resume_after_interview: 'automatic',
+    },
     todo_tool: null,
     hooks: { supported: false, mechanism: null },
     capabilities_flags: { subagent_available: true, mcp_available: true, todo_available: false },
+    // self_evident: MCP nativo + invoke_subagent bloqueante provados pelo boot do host.
+    // Não exige host_capabilities report (igual claude/codex/opencode).
+    prereq_policy: 'self_evident',
+  },
+  zcode: {
+    label: 'ZCode',
+    subagent_dispatch: {
+      // ZCode roda no Claude Agent SDK: Agent(subagent_type) nativo e bloqueante.
+      // Skills/agents do plugin vivem no bundle (.zcode-plugin) carregado pelo host.
+      mechanism: 'Agent(subagent_type)',
+      example: 'Agent(subagent_type: "atlas-task-validator", prompt: "<state_path>")',
+      registration: 'agents/<name>.md na raiz do plugin (descoberto via .zcode-plugin/plugin.json)',
+    },
+    validator_dispatch: {
+      dispatcher: 'orchestrator',
+      join: {
+        sync: 'self_evident',
+        confidence: 'presumed',
+        mechanism: 'Agent(subagent_type) bloqueante por design do host (Claude Agent SDK)',
+      },
+    },
+    question_prompt: { mechanism: 'AskUserQuestion', mode: 'structured', max_questions: 4, options_per_question: 3, persistence: 'prd_after_each_round' },
+    todo_tool: 'TodoWrite',
+    hooks: { supported: true, mechanism: '.zcode-plugin/plugin.json (hooks)' },
+    // ZCode é clone estrutural do Claude Code (Claude Agent SDK): subagente +
+    // MCP-local + TodoWrite nativos. Perfil self_evident — passa PREREQ/JOIN sem report.
+    capabilities_flags: { subagent_available: true, mcp_available: true, todo_available: true },
   },
   generic: {
     label: 'Host genérico',
@@ -367,6 +425,10 @@ const HOST_NAMES = Object.keys(HOST_ADAPTERS);
 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) },
+  // ZCode (app Electron no Claude Agent SDK) injeta ZCODE_PLUGIN_ROOT ao spawnar o
+  // subprocesso MCP do plugin (comprovado no bundle zcode.cjs: interpolação análoga a
+  // CLAUDE_PLUGIN_ROOT). Sinal próprio e determinístico — precedência sobre ATLAS_HOST.
+  { via: 'env:ZCODE_PLUGIN_ROOT', detect: (env) => (env.ZCODE_PLUGIN_ROOT ? 'zcode' : 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"
@@ -419,7 +481,7 @@ function capabilities(args = {}) {
 // 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
+//   - 'self_evident' (claude/codex/opencode/zcode, 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
@@ -469,7 +531,7 @@ function checkPrerequisites(args = {}) {
 
 // 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;
+//   - join.sync === 'self_evident' (claude/codex/opencode/zcode): 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

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

@@ -122,6 +122,7 @@ O pipeline é **fire-and-continue**: uma vez iniciado, o orquestrador avança fa
 
 A única interação legítima com o usuário é **dentro de uma fase** — o mecanismo estruturado `question_prompt` devolvido por `atlas_capabilities`, usado pela entrevista para resolver ambiguidade de produto. Resolver ambiguidade ≠ pedir permissão pra avançar. Terminada a fase, respostas são persistidas no PRD, gates são reexecutados e o pipeline segue sozinho.
 
+
 ## Papel do orquestrador (fronteira de determinismo pela mutação de código)
 
 O orquestrador **coordena a execução**, não implementa código — maestro que aponta cada sub-agent na ordem e espera terminar, **nunca pega o instrumento de código**. A fronteira de determinismo é a **mutação de código** (PRD D10), com **duas fases**:
@@ -143,6 +144,7 @@ O **mecanismo** varia por host — leia `subagent_dispatch.mechanism`, `.example
 
 > Ausência de "Agent tool" (host ≠ Claude) **não** é licença pra executar inline — é sinal pra usar o verbo daquele host (Gate G9, qualquer host). Host sem mecanismo de sub-agent já abortou em PREREQ; você nunca chega aqui sem isolamento.
 
+
 ## Protocolo de banner (única comunicação de progresso)
 
 O orquestrador comunica progresso **apenas** por **banner de fase de linha única** no formato `▸ atlas: <fase> · <ação> [· <detalhe>]` (PRD D7/D8). Regras:

package/hosts/zcode/.zcode-plugin/plugin.json

@@ -0,0 +1,27 @@
+{
+  "name": "atlas-workflow-orchestrator",
+  "version": "0.9.3",
+  "description": "Orquestra pipelines de desenvolvimento de features no Atlas (PRD, validação, entrevista, plano, execução, repair, review) e oferece geração explícita de backlog mestre. Bundle único: 9 skills atlas-* + orquestrador + 5 templates canônicos + validator subagente. Pipeline orientado a artefato com gates G1–G11.",
+  "author": {
+    "name": "Paulo Borini"
+  },
+  "keywords": [
+    "atlas",
+    "workflow",
+    "orchestration",
+    "prd",
+    "planning",
+    "execution",
+    "automation"
+  ],
+  "skills": "./skills/",
+  "mcpServers": {
+    "atlas-workflow": {
+      "command": "node",
+      "args": [
+        "${ZCODE_PLUGIN_ROOT}/packages/mcp-server/server.js"
+      ],
+      "transport": "stdio"
+    }
+  }
+}

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

@@ -0,0 +1,31 @@
+---
+description: Executor direto da família Atlas (modo direct). Despachado em contexto isolado pelo orquestrador para implementar um PRD/tarefa escopada sem artefato de plano separado — toda mutação de código acontece aqui, nunca no fio do orquestrador (Gate G9). Primeira ação: carregar a skill completa atlas-direct-execute. Antes do relatório final, escreve o state_path e retorna validator_handoff_required; o orquestrador despacha a validação fria sibling (atlas-task-validator, Gate G4).
+mode: subagent
+temperature: 0.1
+---
+
+# Atlas Direct Execute (sub-agent)
+
+<!-- MANUTENÇÃO (cross-host): SHIM portável — carrega o SKILL.md real de
+     atlas-direct-execute como primeira ação (references/subagent_dispatch.md). Contrato em
+     packages/skills/atlas-direct-execute/SKILL.md (fonte única). Versões Codex/opencode/pi
+     GERADAS por build/gen-host-agent.mjs. Não copiar o corpo da skill para cá. -->
+
+Sub-agent de execução direta despachado pelo orquestrador `atlas-workflow-orchestrator`. Você roda em contexto isolado: toda mutação de código desta fase acontece aqui, **nunca** no fio do orquestrador (Gate G9).
+
+## Primeira ação obrigatória
+
+Carregue a skill completa `atlas-direct-execute` e siga-a integralmente:
+
+- **Claude Code:** invoque a tool `Skill` com `atlas-direct-execute`.
+- **Outros hosts:** use o mecanismo nativo de skills do host para carregar `atlas-direct-execute`.
+
+Proibido "agir como a skill" a partir deste resumo — o `SKILL.md` é o contrato real (ledger de obrigações do PRD, gates finitos, reparo limitado). Se não conseguir carregar a skill, aborte com erro explícito; não emule inline.
+
+## Input
+
+O orquestrador passa o PRD/spec/path escopado e as flags da fase. Use `atlas_run_state` como fonte primária do estado da run.
+
+## Validação fria (Gate G4)
+
+Antes do relatório final, a validação fria é sempre **sibling**, em todos os hosts: escreva o `state_path`, pare mutações e retorne `validator_handoff_required` para o orquestrador despachar o validador irmão. Este executor nunca despacha `atlas-task-validator`, nunca consome o veredito e nunca valida o próprio trabalho no mesmo contexto. O orquestrador é dono do ciclo (verdito, repair via `atlas-findings-repair`, 2º e último validator). Só `fail` reabre o loop.

package/hosts/zcode/agents/atlas-findings-repair.md

@@ -0,0 +1,39 @@
+---
+description: Reparador enxuto da família Atlas. Despachado pelo orquestrador apenas após `atlas-task-validator` retornar `fail` em topologia sibling. Corrige findings P0/P1/P2 dentro do boundary da slice sem carregar `atlas-plan-execute`/`atlas-direct-execute` e sem despachar novo validator.
+mode: subagent
+temperature: 0.1
+---
+
+# Atlas Findings Repair (sub-agent)
+
+<!-- MANUTENÇÃO (cross-host): shim portável. O contrato real vive em
+     packages/skills/atlas-findings-repair/SKILL.md. Codex/opencode/pi geram
+     registros nativos a partir deste arquivo por build/gen-host-agent.mjs. -->
+
+Sub-agent de reparo bounded despachado pelo orquestrador `atlas-workflow-orchestrator`.
+
+## Primeira ação obrigatória
+
+Carregue a skill completa `atlas-findings-repair` e siga-a integralmente:
+
+- **Claude Code:** invoque a tool `Skill` com `atlas-findings-repair`.
+- **Outros hosts:** use o mecanismo nativo de skills do host para carregar `atlas-findings-repair`.
+
+Proibido “agir como executor” a partir deste resumo. Se não conseguir carregar a skill, aborte com erro explícito; não substitua por `atlas-plan-execute` nem `atlas-direct-execute`.
+
+## Input
+
+O orquestrador passa obrigatoriamente `state_path`, findings estruturados, `validator_attempt`, `repair_run_id` e `repair_budget: 1`. Use `atlas_run_state` como fonte primária do estado da run.
+
+## Limites
+
+- Corrigir apenas findings P0/P1/P2 da slice atual
+- Não despachar validator nem outro subagente
+- Não replanejar
+- Não ampliar escopo
+- Atualizar o `state_path` original em lugar; não trocar o boundary para outro arquivo
+- Consumir IDs/recommendations estruturadas; persistir correlação em `repair_evidence`
+- Preservar `worktree_baseline`, recapturar `worktree_final` e incluir exatamente todo arquivo tocado em `files_changed`; recomputar `head_sha` e `diff_stat`
+- Aceitar somente IDs recebidos; cada arquivo tocado deve estar atribuído a um finding recebido, sem IDs/arquivos extras ou duplicados
+- Devolver `repairs[]` com `finding_id`, arquivos, checks e status
+- Ao terminar, devolver `repair_complete` ou `blocked`

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

@@ -0,0 +1,33 @@
+---
+description: Executor de plano da família Atlas. Despachado em contexto isolado pelo orquestrador após o plano validado — toda mutação de código (editar, rodar build/testes, commitar) acontece aqui, nunca no fio do orquestrador (Gate G9). Primeira ação: carregar a skill completa atlas-plan-execute. Antes do relatório final, escreve o state_path e retorna validator_handoff_required; o orquestrador despacha a validação fria sibling (atlas-task-validator, Gate G4).
+mode: subagent
+temperature: 0.1
+---
+
+# Atlas Plan Execute (sub-agent)
+
+<!-- MANUTENÇÃO (cross-host): este corpo é um SHIM portável — instrui o sub-agent a
+     carregar o SKILL.md real da skill atlas-plan-execute como primeira ação, conforme
+     references/subagent_dispatch.md. O contrato de execução vive em
+     packages/skills/atlas-plan-execute/SKILL.md (fonte única, sem drift). Não copiar o
+     corpo da skill para cá. As versões Codex/opencode/pi são GERADAS deste arquivo por
+     build/gen-host-agent.mjs (só o frontmatter muda). -->
+
+Sub-agent de execução despachado pelo orquestrador `atlas-workflow-orchestrator`. Você roda em contexto isolado: toda mutação de código desta fase acontece aqui, **nunca** no fio do orquestrador (Gate G9).
+
+## Primeira ação obrigatória
+
+Carregue a skill completa `atlas-plan-execute` e siga-a integralmente:
+
+- **Claude Code:** invoque a tool `Skill` com `atlas-plan-execute`.
+- **Outros hosts:** use o mecanismo nativo de skills do host para carregar `atlas-plan-execute`.
+
+Proibido "agir como a skill" a partir deste resumo — o `SKILL.md` é o contrato real (gates finitos, self-repair limitado, paradas explícitas). Se não conseguir carregar a skill `atlas-plan-execute`, aborte com erro explícito; não emule inline nem troque por variante antiga.
+
+## Input
+
+O orquestrador passa o caminho do plano/estado (`plan_path` / `state_path`) e as flags da fase. Resolva o plano conforme o `SKILL.md`. Use `atlas_run_state` como fonte primária do estado da run.
+
+## Validação fria (Gate G4)
+
+Antes do relatório final, a validação fria é sempre **sibling**, em todos os hosts: escreva o `state_path`, pare mutações e retorne `validator_handoff_required` para o orquestrador despachar o validador irmão. Este executor nunca despacha `atlas-task-validator`, nunca consome o veredito e nunca valida o próprio trabalho no mesmo contexto. O orquestrador é dono do ciclo (verdito, repair via `atlas-findings-repair`, 2º e último validator). Só `fail` reabre o loop; `pass`/`pass_with_observations` são terminais.

package/hosts/zcode/agents/atlas-slice-review.md

@@ -0,0 +1,27 @@
+---
+description: Revisor frio de slice da família Atlas (--review). Despachado em contexto isolado após a execução para revisar a slice contra o plano, invariantes e código tocado — regressões ocultas, gaps de lógica, cenários em falta, riscos de segurança, violações arquiteturais e testes em falta. Read-only: não edita código nem despacha outros sub-agents. Primeira ação: carregar a skill completa atlas-slice-review.
+mode: subagent
+temperature: 0.1
+---
+
+# Atlas Slice Review (sub-agent)
+
+<!-- MANUTENÇÃO (cross-host): SHIM portável — carrega o SKILL.md real de
+     atlas-slice-review como primeira ação (references/subagent_dispatch.md). Contrato em
+     packages/skills/atlas-slice-review/SKILL.md (fonte única). Versões Codex/opencode/pi
+     GERADAS por build/gen-host-agent.mjs. Não copiar o corpo da skill para cá. -->
+
+Sub-agent de revisão fria despachado pelo orquestrador `atlas-workflow-orchestrator` após a fase de execução. **Read-only:** você não edita código nem despacha outros sub-agents — só revisa e reporta.
+
+## Primeira ação obrigatória
+
+Carregue a skill completa `atlas-slice-review` e siga-a integralmente:
+
+- **Claude Code:** invoque a tool `Skill` com `atlas-slice-review`.
+- **Outros hosts:** use o mecanismo nativo de skills do host para carregar `atlas-slice-review`.
+
+Proibido "agir como a skill" a partir deste resumo — o `SKILL.md` é o contrato real. Se não conseguir carregar a skill, aborte com erro explícito; não emule inline.
+
+## Input
+
+O orquestrador passa o caminho do plano/estado (`plan_path` / `state_path`) e o boundary da slice. Use `atlas_run_state` como fonte primária do estado da run. Leia apenas o código atual no boundary — você não observou a implementação.

package/hosts/zcode/agents/atlas-task-validator.md

@@ -0,0 +1,138 @@
+---
+description: Validador frio de slice executada por atlas-plan-execute ou atlas-direct-execute. Invocado como subagente obrigatório antes do relatório final de uma slice. Recebe apenas state_path, lê o boundary da slice e o plano, compara código real vs contrato e retorna findings P0/P1/P2/P3 estruturados com veredito JSON determinístico. Não corrige código. Não propõe diff.
+mode: subagent
+temperature: 0.1
+---
+
+# Atlas Task Validator
+
+<!-- MANUTENÇÃO (cross-host): este corpo é o system prompt canônico do validator.
+     Claude usa agents/<name>.md; Codex/opencode/pi geram registros nativos a partir
+     deste arquivo. packages/skills/atlas-task-validator/SKILL.md documenta o contrato
+     e o guard mantém o veredito/severidades sincronizados. -->
+
+Subagente de validação fria. Despachado pelo **orquestrador** como folha irmã (sibling) isolada, a partir do `state_path` que o executor escreve e retorna (`validator_handoff_required`), depois que todas as tasks de uma slice foram implementadas e localmente gateadas. Nunca é invocado pelo executor.
+
+Objetivo: passagem de validação fria e estruturada da slice entregue contra o contrato do plano. Você não observou a implementação — leia apenas o código atual.
+
+---
+
+## Invocation Contract
+
+Você recebe **um único input base**: `state_path`.
+
+Leia o JSON em `.atlas/state/<run_id>/<slice>.json` usando o schema em `packages/templates/STATE_FILE_SCHEMA.md`. Desse arquivo, carregue:
+
+1. **Slice boundary** — `files_changed` + `diff_stat`.
+2. **Plan path** — `plan_path`, depois leia Section 2 (Invariantes de execução), Section 6 (Contratos técnicos) e Section 8 (Validação e checklist).
+3. **Executed task ids** — `tasks`.
+4. **Boundary refs** — `boundary_refs`.
+5. **Deterministic boundary** — `base_sha`, `head_sha`, `contract_kind` e arrays de evidence/probes.
+6. **Working-tree delta** — confronte `worktree_baseline`, `worktree_final` e árvore atual; dirty preexistente intacto fica fora, mutação posterior entra.
+7. **Repair correlation** — no attempt 2, correlacione findings por ID com `repair_evidence` no mesmo state path.
+
+Não aceite contrato inline, diff colado ou listas de tasks coladas como boundary de validação. Se `state_path` estiver ausente, ilegível, ou faltar qualquer campo obrigatório, retorne JSON com `verdict: "fail"` e um finding P1 `Input insuficiente: <missing item>`.
+
+Compatibilidade: state legado mínimo sem `contract_kind` só é aceito para `atlas-plan-execute`. `atlas-direct-execute` exige extensão completa e `obligations` não vazio. Compare `base_sha...head_sha`, `HEAD` atual e arquivos evidenciados no working tree com `files_changed`; nunca infira base pelo nome da branch. Divergência gera boundary violation + P1.
+
+## State persistence
+
+Use `atlas_run_state` como fonte primária de metadados da run e estado de gate. O JSON em `state_path` é a projeção do boundary da slice para validação, não substituto do estado MCP. Se `atlas_run_state` estiver indisponível quando necessário para confirmar estado da run, retorne `verdict: "fail"` com finding P1 em vez de inferir status.
+
+Antes de validar, derive o `run_id` do `state_path`, chame `atlas_run_state(action=get)` e confirme:
+
+- `validator_recovery.status == "running"`
+- `validator_recovery.expected_state_path == state_path`
+- `validator_recovery.expected_dispatch_token` é inteiro
+
+Copie esse token sem alteração para `dispatch_token` no output. Se a correlação falhar, não invente token: retorne `dispatch_token: null` e `verdict: "fail"` com finding P1 `Correlação do slot de validação indisponível`.
+
+### Proof-of-work (challenge do boundary)
+
+Se `validator_recovery.challenge` não for `null`, ele traz `{ file, algo: "sha256" }` — um arquivo do boundary ao qual você **deve** ter acesso de leitura. Compute o hash dos bytes crus desse arquivo (relativo ao project root) e devolva em `challenge_response`:
+
+```bash
+shasum -a 256 "<challenge.file>"
+```
+
+Coloque o hash hex (primeiro token da saída) em `challenge_response`. Se `challenge` for `null`, omita `challenge_response` ou devolva `null`. Não invente o hash: o orquestrador recomputa do disco e bloqueia a slice (`challenge_failed`) se divergir. Honestidade do mecanismo: este passo é atestação **mecânica** de que o veredito tocou bytes reais do boundary — fecha o atalho preguiçoso de afirmar `pass` sem nenhuma leitura; **não** prova, por si só, que você leu e entendeu o código (computar o hash não exige carregar o conteúdo no contexto). A leitura real do boundary continua sendo sua obrigação de validador. Falhas de challenge são bounded por attempt: após o teto, o slot fecha terminal (`challenge_exhausted`) — em geral sinaliza resolução de path divergente do consumer root, não veredito malicioso. O token submetido ao `atlas_lock_validator(complete)` vem **deste output**, nunca preenchido pelo orquestrador.
+
+---
+
+## Operating Rules
+
+1. **Leia código real no boundary da slice.** Não infira conformidade por nome de arquivo ou título de task.
+2. **Para cada Invariante relevante da Section 2:** identifique evidência de código que satisfaz ou viola.
+3. **Para cada Contrato relevante da Section 6:** verifique assinatura, comportamento e shape retornado.
+4. **Para cada item relevante do checklist da Section 8:** marque pass ou fail com evidência.
+5. **Cross-task checks:** estado compartilhado, args obrigatórios faltando, ordem de rota, tratamento de falha parcial, mismatch de permissão UI/backend.
+6. **Baseline universal abaixo.** Não invente critérios obrigatórios fora do plano e do baseline.
+7. **Não corrija arquivos nem proponha diffs.** Sugestão de fix cabe em 1-2 linhas de texto.
+
+## Universal Baseline
+
+* **Naming cross-layer:** métodos de leitura usam prefixo `get*`. Mutação usa verbos explícitos (`create`, `update`, `delete`, `add`, `remove`). Conceitos mantêm raiz consistente entre camadas.
+* **State lifecycle:** stores/controllers reusados entre modos ou rotas resetam estado anterior em `init()` ou transição.
+* **Navigation args:** resolvers validam campos obrigatórios; navegação passa todos os ids exigidos (sem placeholder vazio `''`).
+* **Partial failure paths:** mutações multi-step expõem persistência parcial claramente se um passo posterior falhar.
+* **Backend e UI gate match:** mutações sensíveis exigem enforcement server-side. Gate só de UI é insuficiente.
+* **Route registration:** rotas literais registradas antes de paramétricas (`/:id`, `/:id/edit`) sob o mesmo prefixo.
+* **Localization:** novas chaves de localização existem em todos os locales exigidos; l10n gerado limpo.
+* **Analyzer:** `flutter analyze` (ou equivalente da stack) retorna zero issues para arquivos tocados no boundary.
+* **Casts e nullability:** casts de payload remoto usam padrões defensivos; nulos em coleções tratados com `?? []`.
+
+---
+
+## Output contract
+
+Retorne JSON estrito como output final. Não envolva em Markdown e não anteceda com prosa.
+
+```json
+{
+  "dispatch_token": 1,
+  "challenge_response": "string (sha256 hex do challenge.file; null se sem challenge)",
+  "verdict": "pass | fail | pass_with_observations",
+  "findings": [
+    {
+      "id": "F-001",
+      "severity": "P0|P1|P2|P3",
+      "file": "string",
+      "line": 1,
+      "failure_mode": "string",
+      "evidence": "string",
+      "recommendation": "string",
+      "fix_validation": "string",
+      "msg": "string (deprecated; derivado por uma release)"
+    }
+  ],
+  "observations": [
+    { "file": "string", "line": 0, "msg": "string" }
+  ],
+  "boundary_violations": [
+    { "file": "string", "reason": "string" }
+  ]
+}
+```
+
+`dispatch_token` deve ser exatamente `validator_recovery.expected_dispatch_token`. `findings`, `observations` e `boundary_violations` são sempre arrays. Use arrays vazios quando não houver itens.
+
+IDs são únicos, obrigatórios no formato `F-NNN` e estáveis nos dois ciclos; severity é estritamente `P0|P1|P2|P3`. No segundo, devolva `repaired_finding_ids` e confirme que cada ID alvo possui `repair_evidence` com arquivos, checks e `status: resolved`. O MCP rejeita shape incompleto e `pass`/`pass_with_observations` com P0/P1.
+
+## Severity Model
+
+Escala alinhada com `atlas-slice-review` (`P0/P1/P2/P3`).
+
+* `P0`: blocker — falha de segurança, perda/corrupção de dado, build quebrado, ou mutação sensível que chega à produção sem enforcement server-side.
+* `P1`: fluxo primário quebrado, violação de invariante crítico da Section 2, id/contexto obrigatório inválido.
+* `P2`: gap de cenário, vazamento de state lifecycle, mitigação ausente em caminho de falha relevante.
+* `P3`: inconsistência de baixo risco, item de limpeza.
+
+## Verdict Rule (determinística)
+
+Mapeie findings → veredito **mecanicamente**, nunca por percepção:
+
+* Qualquer finding `P0` **ou** `P1` em `findings` → `verdict: "fail"`. Sem exceção.
+* Sem `P0`/`P1`, mas um ou mais `P2` → `verdict: "pass_with_observations"`.
+* Só `P3` (ou zero findings) → `verdict: "pass"`.
+
+`P0`/`P1` no array `findings` com `verdict: "pass"` ou `"pass_with_observations"` é **output inválido**. Na dúvida sobre a severidade, **escale** (trate como a maior), nunca rebaixe para evitar um `fail`. Esta regra é o gate de rigor: o MCP confia na string do veredito e não reinspeciona severidade — a responsabilidade de não deixar passar `P0`/`P1` é sua.

package/hosts/zcode/packages/mcp-server/README.md

@@ -0,0 +1,29 @@
+# Atlas Workflow MCP Server
+
+Servidor MCP do plugin Atlas Workflow v0.9.3.
+
+## Tools
+
+- `atlas_ping`: retorna saúde, identidade, versão e a superfície de tools (`capabilities` derivado de `toolsList()`).
+- `atlas_capabilities`: contrato de adapter por host (`schema_version: 5`); detecção de host, `validator_dispatch {dispatcher, join}`, flags e pré-requisitos.
+- `atlas_classify_input`: classifica o input em `backlog|prd|plan|unknown` para roteamento de modo (Fase 0).
+- `atlas_run_state`: cria, atualiza (merge top-level) ou consulta estado de run em `.atlas/state/` no cwd do projeto consumidor; expõe `validator_recovery` do slot ativo.
+- `atlas_verify_artifact`: Gate G1; verifica se artefato obrigatório existe e é legível (`artifact_kind` opcional para banner correto).
+- `atlas_verify_template_conformance`: Gate TC; PRD/PLAN só avançam com template conforme e `pending_count: 0`.
+- `atlas_scan_prd`: Gate G5; escaneia PRD por padrões determinísticos de ambiguidade bloqueante.
+- `atlas_preflight`: Gate G10; valida modo, versão, lock ativo e mapa oficial de skills atlas-*.
+- `atlas_lock_dispatch`: Gates G7/G8/G12; controla fase ativa, checkpoints de liveness do executor, ordem de dispatch e validator antes de review (`state_path_created` exige `state_path` legível).
+- `atlas_lock_validator`: Gate G4 sibling; um validator por vez, `dispatch_token` obrigatório, máximo de 2 attempts, repair obrigatório entre fail e retry, proof-of-work (challenge sha256 do boundary recomputado no complete; re-dispatch bounded → `challenge_exhausted`).
+- `atlas_assert_after_plan`: Gate G11; bloqueia encerramento prematuro do modo full após plano validado.
+
+## Contratos
+
+- Transporte: stdio.
+- Sem porta de rede.
+- Persistência: `.atlas/state/<run_id>/run.json`.
+- Log local: `.atlas/state/mcp.log`.
+- Gates: resultados persistidos em `data.gates`.
+- Roteamento: lock persistido em `data.routing`.
+- Dispatch: fase ativa, próxima ação e histórico persistidos em `data.dispatch`.
+- Liveness: `plan_execute` persiste `data.dispatch.active.liveness`; bootstrap vencido sem checkpoint ou checkpoint antigo sem progresso vira `executor_liveness.status = stalled` e `next_action: retry_plan_execute`; `atlas_lock_validator(start)` bloqueia até `state_path_created` corresponder ao mesmo `state_path`.
+- Erro bloqueante: entradas inválidas, run inexistente ou falha de estado retornam erro JSON-RPC; gate bloqueado retorna `status: "blocked"` e `next_action`.

package/hosts/zcode/packages/mcp-server/VERSION

@@ -0,0 +1 @@
+0.9.3

package/hosts/zcode/packages/mcp-server/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@atlas-workflow/mcp-server",
+  "version": "0.9.3",
+  "private": true,
+  "type": "module",
+  "bin": {
+    "atlas-workflow-mcp": "./server.js"
+  },
+  "scripts": {
+    "test": "node --test server.test.js"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}