atlas-workflow 0.9.2 → 0.9.4

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

@@ -1,6 +1,6 @@
 ---
 name: atlas-workflow-orchestrator
-description: "Orquestra pipeline completo de desenvolvimento de features: /workflow <mode> <input-type> [flags]. Automatiza PRD generation → validação → entrevista (se necessário) → planejamento → execução → review (opcional). Pipeline orientado a artefato com gates duros: cada fase só conta se produzir arquivo verificável em disco."
+description: "Orquestra pipeline completo de desenvolvimento de features: /workflow <mode> <input-type> [flags]. Automatiza PRD generation → validação → entrevista (se necessário) → planejamento → execução → review (opcional) e oferece audit universal sem correção. Pipeline orientado a artefato com gates duros: cada fase só conta se produzir arquivo verificável em disco."
 category: Development Automation
 ---
 
@@ -13,17 +13,18 @@ Orquestra pipelines de desenvolvimento de features no projeto Atlas, automatizan
 ## Sintaxe
 
 ```
-/workflow <mode> <input-type> [flags]
+/workflow <mode> <input-type|target> [flags]
 ```
 
 ### Modos
 
-Três modos **canônicos de execução** — `full`, `direct`, `execute` (PRD §5 D1) — mais o modo `interview-only`, que permanece **separado** (entrevista sem execução; PRD D2, não é colapsado em `full`).
+Três modos **canônicos de execução** — `full`, `direct`, `execute` (PRD §5 D1) — mais os modos sem execução `interview-only` e `audit`.
 
 - **`full`** — pipeline completo: PRD → validação → entrevista (se necessário) → **plano (artefato obrigatório)** → executor → review (opcional)
 - **`direct`** — pipeline enxuto: PRD → validação → entrevista (se necessário) → `atlas-direct-execute` → review (opcional). **Não produz plano de handoff** — a diferença real para `full` é exatamente essa.
 - **`execute`** — recebe um **`PLAN_*.md` pronto** e o executa **sem gerar plano** (PRD D1). Entrada = caminho de plano; reverifica o artefato + conformidade de template e despacha `plan_execute` direto. Não regera nem replaneja: ajustes de plano pedem `full`. `atlas_assert_after_plan` (gate pós-plano do `full`) **não se aplica** em `execute` — o plano já é o input; o equivalente é a reverificação na entrada (PRD D13). **Não há alias `plan`**: usar `plan` como modo é ambíguo com planejamento documental e deve ser rejeitado como modo inválido.
 - **`interview-only`** — entrevista direta (ex: brainstorm, resolução de decisões). Entrevista **sem execução**: não usa `guarantee_level` no fluxo (não há execução de código a garantir). Permanece modo separado (PRD D2).
+- **`audit`** — auditoria universal sem correção de código: lê target/boundary, regras locais e stack detectada; gera relatório de achados e, com `--handoff`, plano Atlas-style para correção futura. **Não executa plano, não chama executor e não altera código.**
 
 ### Input Types
 
@@ -31,11 +32,14 @@ Três modos **canônicos de execução** — `full`, `direct`, `execute` (PRD §
 - **`idea`** — Indicação/brainstorm curto
 - **`prd`** — Path para PRD existente ou nome do arquivo
 - **`brainstorm`** — Texto livre (só para `interview-only`)
+- **`target`** — Path/feature/módulo auditável (só para `audit`)
 
 ### Flags
 
 - `--interview` — força entrevista de PRD mesmo sem ambiguidades detectadas
 - `--review` — executa slice-review ao final (senão é opcional)
+- `--handoff` — em `audit`, escreve plano Atlas-style em `.atlas/plans/` derivado dos achados evidenciados; não executa
+- `--scope <descrição>` — em `audit`, restringe o boundary lógico dentro do target
 - `--help` — mostra sintaxe completa
 
 ## Exemplos
@@ -55,6 +59,9 @@ Três modos **canônicos de execução** — `full`, `direct`, `execute` (PRD §
 
 /workflow execute plan "/path/to/PLAN_S05_login.md"
 → Reverifica o plano (artifact + TC), executa direto via plan_execute + validador frio. Não gera plano.
+
+/workflow audit "apps/mobile/lib/features/auth" --handoff
+→ Audita somente o target informado contra regras locais + stack detectada + Ponytail pass; gera relatório e `PLAN_AUDIT_*.md` sem execução.
 ```
 
 ---
@@ -63,7 +70,7 @@ Três modos **canônicos de execução** — `full`, `direct`, `execute` (PRD §
 
 Executar **antes** de iniciar o pipeline. Se qualquer item falhar, **parar e reportar** — nunca emular.
 
-1. **Parse** dos argumentos `<mode> <input-type> [input] [flags]`. Se inválido ou `--help` → mostrar sintaxe e parar.
+1. **Parse** dos argumentos `<mode> <input-type|target> [input] [flags]`. Se inválido ou `--help` → mostrar sintaxe e parar. Em `audit`, o segundo argumento é `target`, não `input-type`.
 2. **Chamar MCP `atlas_ping`.** Se não responder, versão vier vazia, `version_check.status` vier bloqueado ou capacidades não listarem os gates exigidos pelo modo → abortar com erro de MCP indisponível/drift. Não seguir por prosa.
 2a. **Chamar MCP `atlas_capabilities`.** Ler `host`, `subagent_dispatch`, `validator_dispatch`, `capabilities_flags` e `required_deps`. Determinar a **disponibilidade real** dos pré-requisitos essenciais neste host: o subagente do plugin é despachável? o MCP está vivo (ping ok)? Em hosts com `required_deps` (ex.: pi: `pi-mcp-adapter` + `pi-subagents`), confirmar que cada dep está presente; se faltar, o pré-requisito correspondente é `false`.
 2b. **Chamar MCP `atlas_classify_input`** no input informado (`input_path`), **antes de rotear** (PRD D3/D6). `classify_input` é para **artefato em arquivo** (path em disco). A tool devolve `artifact_type` ∈ {`backlog`, `prd`, `plan`, `idea`, `unknown`} (verdade forte = TC de plano passa) e um `banner` de roteamento já pronto. **O tipo de input é fato e prevalece sobre o modo pedido** (intenção). Aplicar o roteamento:
@@ -88,9 +95,9 @@ Executar **antes** de iniciar o pipeline. Se qualquer item falhar, **parar e rep
       Motivo: dependência de backlog não está `done`
       Ação: executar <dep> antes de <id>
    ```
-4. **Usar a cadeia única `atlas-*`.** Cliente (Claude Code, Cursor, Codex App) é host de execução, não família de skills. Não existe roteamento por cliente.
+4. **Usar a cadeia única `atlas-*`.** Cliente (Claude Code, Cursor, Codex App, Antigravity, ZCode, OpenCode, Pi CLI) é host de execução, não família de skills. Não existe roteamento por cliente.
 5. **Carregar defaults do pacote do plugin** (`defaults/paths.md` e `references/subagent_dispatch.md`). Não exigir config na raiz do repositório usuário.
-6. **Verificar disponibilidade dos ids `atlas-*`.** Para cada skill exigida pelo modo, confirmar que o id exato é **invocável** no host. Para as skills de **execução/validação/review** (`plan_execute`, `direct_execute`, `task_validator`, `findings_repair`, `slice_review`), confirmar também que são **despacháveis pelo verbo nativo do host** — leia `atlas_capabilities.subagent_dispatch.mechanism` (não assuma "Agent tool"; no Codex é `spawn_agent(agent_type)`, no opencode `@<name>`, no pi `subagent({...})`). No Codex, `$<skill>` é ativação in-context de skill e **não** conta como sub-agent isolado para execução. Para as skills **documentais** (`prd_generator`, `prd_interview`, `plan_handoff`), basta invocabilidade no fio principal; não exigir despachabilidade como sub-agent.
+6. **Verificar disponibilidade dos ids `atlas-*`.** Para cada skill exigida pelo modo, confirmar que o id exato é **invocável** no host. Para as skills de **execução/validação/review** (`plan_execute`, `direct_execute`, `task_validator`, `findings_repair`, `slice_review`), confirmar também que são **despacháveis pelo verbo nativo do host** — leia `atlas_capabilities.subagent_dispatch.mechanism` (não assuma "Agent tool"; no Codex é `spawn_agent(agent_type)`, no opencode `@<name>`, no pi `subagent({...})`, no ZCode e Claude é `Agent(subagent_type)`). No Codex, `$<skill>` é ativação in-context de skill e **não** conta como sub-agent isolado para execução. Para as skills **documentais/de leitura** (`prd_generator`, `prd_interview`, `plan_handoff`, `audit`), basta invocabilidade no fio principal; não exigir despachabilidade como sub-agent.
    - **Skill ausente é bloqueio** (Gate G10): não substitua por skill nativa, variante antiga ou prompt inline.
    - **Conflito plugin × skill nativa:** use somente o id exato retornado pelo preflight. Se o host não permitir comprovar que a skill vem do plugin esperado, aborte e peça remoção/desativação manual da nativa; não resolva por tentativa silenciosa.
    - **Nunca substituir por variante de executor** (Gate G10).
@@ -102,7 +109,7 @@ Executar **antes** de iniciar o pipeline. Se qualquer item falhar, **parar e rep
       Ação: instalar/ativar o plugin ou corrigir o pacote atlas-* disponível no host
    ```
    **PROIBIDO o fallback "implementação direta" / "contratos equivalentes inline".** Não existe caminho onde o orquestrador faz plano ou código no próprio fio. Emulação inline e fallback direto são a falha-raiz que esta skill proíbe — se não há sub-agent, **para**. (Gate G7.)
-8. **Rejeitar conflito de modo:** se o pedido tiver `full`/`direct` junto com "sem patch", "sem editar código", "planejamento apenas", "handoff only" ou equivalente, **pare antes de gerar artefatos**. `full` executa `atlas-plan-execute`; `direct` executa `atlas-direct-execute`; não existe interpretação plan-only implícita.
+8. **Rejeitar conflito de modo:** se o pedido tiver `full`/`direct` junto com "sem patch", "sem editar código", "planejamento apenas", "handoff only" ou equivalente, **pare antes de gerar artefatos**. `full` executa `atlas-plan-execute`; `direct` executa `atlas-direct-execute`; não existe interpretação plan-only implícita. Se o usuário quer diagnóstico sem patch, o modo correto é `audit`.
 9. **Declarar o plano de execução** (1 bloco curto): `run_id`, modo, **ids exatos de cada sub-agent**, sequência de fases, artefatos esperados e tools MCP que sustentarão cada gate. Só então iniciar a Fase 1.
 
 ---
@@ -113,7 +120,7 @@ O pipeline é **fire-and-continue**: uma vez iniciado, o orquestrador avança fa
 
 **Proibido (regressão, PRD §6):**
 - Pedir confirmação para avançar: "Quer que eu gere o PRD?", "posso seguir?", "continuo?", "devo despachar o executor?". A resposta é sempre sim — **execute**. Se a próxima fase tem artefato a produzir, produza.
-- Inventar modo fora do contrato. **Não existe "Modo Discussão", "modo análise", "dry-run"** ou similar. Os únicos modos são `full`/`direct`/`execute`/`interview-only`. Pedido em linguagem natural que nomeia um modo (ex.: "atlas full backlog s40") **executa esse modo** — não vira pergunta nem resumo passivo.
+- Inventar modo fora do contrato. **Não existe "Modo Discussão", "modo análise", "dry-run"** ou similar. Os únicos modos são `full`/`direct`/`execute`/`interview-only`/`audit`. Pedido em linguagem natural que nomeia um modo (ex.: "atlas full backlog s40") **executa esse modo** — não vira pergunta nem resumo passivo.
 - Parar por decisão em aberto. Decisão pendente de **qualquer fonte** (scan de PRD, entrevista, `PERGUNTAS_EM_ABERTO.md`, doc de discussão/decisões como `DISCUSSAO_*.md`, ou o próprio backlog) **não é blockage**: gera o PRD se ainda não existe, dispara `atlas-prd-interview` sobre ele, propaga e **continua**. Nunca oferecer "responda só: seguir com recomendação ou D=...". Ver "Decisão em aberto ≠ parada".
 
 **PRD ausente em `full`/`direct`** = o passo "Generate PRD" **gera o PRD automaticamente** (invoca o id resolvido para `prd_generator` / autoria documental no fio principal). Nunca perguntar "quer que eu gere?".
@@ -122,6 +129,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**:
@@ -137,12 +145,15 @@ O **mecanismo** varia por host — leia `subagent_dispatch.mechanism`, `.example
 
 - **claude:** `Agent(subagent_type: "atlas-<exec>", prompt: ...)`
 - **codex:** `spawn_agent(agent_type: "atlas-<exec>", items: [{ type: "text", text: "<state_path ou task>" }])` (custom agent nativo em `CODEX_HOME/agents/atlas-<exec>.toml`; `.codex/agents/` do bundle é gerado). `$atlas-*` sozinho **não** isola contexto — use `spawn_agent`.
+- **zcode:** `Agent(subagent_type: "atlas-<exec>", prompt: "<state_path>")` (Claude Agent SDK — mesmo verbo de Claude, formato `agents/<name>.md` no plugin root; `ZCODE_PLUGIN_ROOT` injetado pelo host)
 - **opencode:** `@atlas-<exec>` (ou auto por description)
 - **pi:** `subagent({ agent: "atlas-<exec>", task, context: "fresh" })`
+- **antigravity:** `define_subagent(name, system_prompt)` + `invoke_subagent(Subagents: [{TypeName, Role, Prompt, Workspace}])`
 - **generic:** subagente nativo do host
 
 > 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:
@@ -182,7 +193,7 @@ Regras inegociáveis. Violação = parar, não contornar.
 
 ### [EXEC] — passo comum de execução + validação
 
-`atlas_lock_dispatch(action=start, phase=plan_execute)` em todos os modos; despachar como sub-agent blocking o `routing.executor_skill` devolvido pelo preflight: `atlas-plan-execute` em `full`/`execute`, `atlas-direct-execute` em `direct`. O executor emite checkpoints G12; sem retorno/progresso, chamar `atlas_lock_dispatch(action=status, phase=plan_execute)` e tratar `executor_bootstrap_timeout`/`executor_progress_timeout` como `stalled`/retry — nunca como execução em andamento. O executor retorna `validator_handoff_required` com `state_path`; o MCP só abre o slot após o checkpoint `state_path_created` para esse mesmo `state_path`. Validação sempre **sibling**: `atlas_lock_validator(action=start)`, despachar **um** `task_validator`, exigir no output o `dispatch_token` do slot e fechar com `validator_run_id` + `dispatch_token`. Em `fail`: `repair_start`, despachar `atlas-findings-repair` com `{state_path, findings, validator_attempt, repair_run_id, repair_budget: 1}`, exigir atualização do mesmo `state_path`, fechar com `repair_run_id` e rodar o **2º e último** validator. `passed`/`passed_with_observations` são terminais aprovados; status diferente bloqueia review e output completed.
+`atlas_lock_dispatch(action=start, phase=plan_execute)` em todos os modos; despachar como sub-agent blocking o `routing.executor_skill` devolvido pelo preflight: `atlas-plan-execute` em `full`/`execute`, `atlas-direct-execute` em `direct`. O executor emite checkpoints G12; sem retorno/progresso, chamar `atlas_lock_dispatch(action=status, phase=plan_execute)` e tratar `executor_bootstrap_timeout`/`executor_progress_timeout` como `stalled`/retry — nunca como execução em andamento. O executor retorna `validator_handoff_required` com `state_path`; o MCP só abre o slot após o checkpoint `state_path_created` para esse mesmo `state_path`. Validação sempre **sibling**: `atlas_lock_validator(action=start)`, despachar **um** `task_validator`, exigir no output o `dispatch_token` do slot e fechar com `validator_run_id` + `dispatch_token`. Se o output do validator for persistido em arquivo (`validator-output.json` ou equivalente), passar `validator_output_path` no `atlas_lock_validator(action=complete)` ou validar o arquivo com `atlas_verify_artifact(artifact_kind=json)` antes de declarar closure; JSON inválido bloqueia. Em `fail`: `repair_start`, despachar `atlas-findings-repair` com `{state_path, findings, validator_attempt, repair_run_id, repair_budget: 1}`, exigir atualização do mesmo `state_path`, fechar com `repair_run_id` e rodar o **2º e último** validator. `passed`/`passed_with_observations` são terminais aprovados; status diferente bloqueia review e output completed.
 
 ### Full mode
 
@@ -231,6 +242,16 @@ Entrada: um **`PLAN_*.md` pronto**. Artefatos esperados: (plano já existe) →
 
 > `interview-only` é entrevista **sem execução**: não há fase `plan_execute` nem `guarantee_level` no fluxo (nada de código a garantir). A autoria do esboço é documental e livre.
 
+### Audit mode
+
+Entrada: um `target` auditável, com flags opcionais `--handoff` e `--scope <descrição>`. Artefatos esperados: relatório de auditoria em resposta; se `--handoff`, plano Atlas-style salvo em `.atlas/plans/PLAN_AUDIT_<slug>.md`. **Não há execução, `plan_execute`, validator, repair, review nem `guarantee_level`.**
+
+1. **Parse / target** — resolver target real em disco. Se o target não for localizável, parar com pedido objetivo de path/boundary.
+2. **Pré-flight leve** — `atlas_ping` → `atlas_capabilities` → `atlas_preflight(mode=audit)` para travar versão/família `atlas-*`. Não chamar `atlas_classify_input`: audit não roteia input para execução.
+3. **Invocar `atlas-audit` no fio principal** — carregar o `SKILL.md` real, auditar só o boundary informado, ler regras locais, detectar stack por manifests/configs/comandos reais, aplicar checklist universal e Ponytail pass final.
+4. **Output** — relatório com stack detectada, regras consultadas, boundary, achados P0/P1/P2/P3 com `arquivo:linha`, gaps por área e limitações.
+5. **Handoff opcional** — se `--handoff`, escrever `PLAN_AUDIT_*.md` **conforme ao `PLAN_TEMPLATE.md`** (cabeçalho com linha `| **PRD** | N/A — origem auditoria |`, ref a `BOUNDARY_PRD_PLAN.md`, §1–§6/§8, tasks `#### T01.`), derivado somente dos achados evidenciados — passa no gate TC e é consumível por `/workflow execute plan`. Reportar o path e **parar aqui. Não chamar executor automaticamente.**
+
 ---
 
 ## Validação automática de PRD
@@ -328,7 +349,7 @@ Se `full` gerou `PLAN_*.md` mas não despachou `plan_execute`, o cabeçalho deve
 
 ## Skills envolvidas
 
-`atlas-backlog-generator` aparece apenas para descoberta do catálogo: é **explicit-only** e nunca integra `full`/`direct`/`execute`/`interview-only`. A cadeia automática começa em PRD/input já fornecido.
+`atlas-backlog-generator` aparece apenas para descoberta do catálogo: é **explicit-only** e nunca integra `full`/`direct`/`execute`/`interview-only`/`audit`. A cadeia automática começa em PRD/input já fornecido.
 
 | Skill | Entrada | Saída (artefato) |
 |-------|---------|------------------|
@@ -336,6 +357,7 @@ Se `full` gerou `PLAN_*.md` mas não despachou `plan_execute`, o cabeçalho deve
 | `atlas-sprint-prd-generator` | sprint_id/indicação | `PRD_*.md`, decisions_found |
 | `atlas-prd-interview` | prd_path, ambiguities | `PRD_*.md` atualizado, decisions |
 | `atlas-plan-handoff` | prd_path | `PLAN_*.md` |
+| `atlas-audit` | target, flags (`--handoff`, `--scope`) | relatório de auditoria; `.atlas/plans/PLAN_AUDIT_*.md` opcional sem execução |
 | `atlas-plan-execute` | plan_path (`full` / `execute`) | diff de código, evidência, `state_path` |
 | `atlas-direct-execute` | prd_path/spec/task (`direct`) | diff de código, evidência, `state_path` |
 | `atlas-slice-review` | diff/output | review_feedback |

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

@@ -1,6 +1,6 @@
 # Atlas Workflow MCP Server
 
-Servidor MCP do plugin Atlas Workflow v0.9.1.
+Servidor MCP do plugin Atlas Workflow v0.9.4.
 
 ## Tools
 
@@ -11,7 +11,7 @@ Servidor MCP do plugin Atlas Workflow v0.9.1.
 - `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_preflight`: Gate G10; valida modo, versão, lock ativo e mapa oficial de skills atlas-*; `guarantee_level` só aparece em modos com execução.
 - `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.

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

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

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

@@ -64,11 +64,12 @@ const WORKFLOW_CONFIG = {
     plan_handoff: 'atlas-plan-handoff',
     plan_execute: 'atlas-plan-execute',
     direct_execute: 'atlas-direct-execute',
+    audit: 'atlas-audit',
     findings_repair: 'atlas-findings-repair',
     slice_review: 'atlas-slice-review',
     task_validator: 'atlas-task-validator',
   },
-  modes: ['full', 'direct', 'execute', 'interview-only', 'interview_only'],
+  modes: ['full', 'direct', 'execute', 'interview-only', 'interview_only', 'audit'],
 };
 
 const VALIDATOR_MAX_ATTEMPTS = 2;
@@ -104,7 +105,7 @@ function repairRunId(runId, attempt, timestamp) {
 // 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):
+// (interview-only/audit) 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 = {
@@ -283,23 +284,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 +426,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 +482,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 +532,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
@@ -1098,6 +1161,16 @@ function runState(args = {}) {
   throw rpcError(-32602, `Ação inválida para atlas_run_state: ${action}`);
 }
 
+function validateJsonArtifactFile(absolutePath) {
+  try {
+    const content = fs.readFileSync(absolutePath, 'utf8');
+    const parsed = JSON.parse(content);
+    return { ok: true, parsed_type: Array.isArray(parsed) ? 'array' : typeof parsed };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
 function verifyArtifact(args = {}) {
   const runId = validateRunId(args.run_id);
   const artifactPath = requiredString(args, 'artifact_path');
@@ -1110,7 +1183,9 @@ function verifyArtifact(args = {}) {
   const artifactKind = optionalString(args, 'artifact_kind');
   const okBanner = artifactKind === 'prd'
     ? renderBanner('prd_ok', {})
-    : renderBanner('plano', {});
+    : artifactKind === 'json'
+      ? renderBanner('validacao', { status: 'json_ok' })
+      : renderBanner('plano', {});
   let result;
 
   try {
@@ -1127,15 +1202,43 @@ function verifyArtifact(args = {}) {
       };
     } 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',
-      };
+      if (artifactKind === 'json') {
+        const jsonCheck = validateJsonArtifactFile(absolutePath);
+        if (!jsonCheck.ok) {
+          result = {
+            gate: 'G1',
+            status: 'blocked',
+            artifact_path: artifactPath,
+            bytes: stat.size,
+            timestamp,
+            banner: renderBanner('preflight_fail', { motivo: `json inválido: ${artifactPath}` }),
+            error: `Artefato JSON inválido: ${artifactPath}`,
+            cause: jsonCheck.error,
+            next_action: 'corrigir_json_ou_regenerar_por_serializer',
+          };
+        } else {
+          result = {
+            gate: 'G1',
+            status: 'passed',
+            artifact_path: artifactPath,
+            bytes: stat.size,
+            parsed_type: jsonCheck.parsed_type,
+            timestamp,
+            banner: okBanner,
+            next_action: 'avançar',
+          };
+        }
+      } else {
+        result = {
+          gate: 'G1',
+          status: 'passed',
+          artifact_path: artifactPath,
+          bytes: stat.size,
+          timestamp,
+          banner: okBanner,
+          next_action: 'avançar',
+        };
+      }
     }
   } catch (error) {
     result = {
@@ -1757,6 +1860,7 @@ function expectedNextPhase(routing, dispatch) {
   if (routing.mode === 'full') return 'plan_handoff';
   if (routing.mode === 'direct') return 'plan_execute';
   if (routing.mode === 'execute') return 'plan_execute';
+  if (routing.mode === 'audit') return 'audit_report';
   return 'prd_interview';
 }
 
@@ -2702,6 +2806,7 @@ function validatorComplete(args, context) {
   // validator. Sem token não existe garantia anti-stale completa.
   const dispatchToken = optionalInteger(args, 'dispatch_token');
   const challengeResponse = optionalString(args, 'challenge_response');
+  const validatorOutputPath = optionalString(args, 'validator_output_path');
 
   if (!cycle.active) {
     // S10: slot já fechado. Distinguir retorno duplicado já aplicado (idempotente
@@ -2872,6 +2977,28 @@ function validatorComplete(args, context) {
   }
   const challengeVerified = !cycle.active.challenge ? 'no_challenge' : 'verified';
 
+  if (validatorOutputPath) {
+    const outputPath = resolveConsumerPath(validatorOutputPath, args);
+    const jsonCheck = validateJsonArtifactFile(outputPath);
+    if (!jsonCheck.ok) {
+      return {
+        gate: 'G4',
+        action: 'complete',
+        status: 'blocked',
+        timestamp,
+        validator_attempt: cycle.active.attempt,
+        validator_run_id: activeValidatorRunId,
+        state_path: statePathValue,
+        validator_output_path: validatorOutputPath,
+        validator_status: 'invalid_validator_output_json',
+        error: `Output JSON do validator inválido: ${validatorOutputPath}`,
+        cause: jsonCheck.error,
+        impact: 'relatorio_do_validador_nao_e_parseavel_como_json_confiavel',
+        next_action: 'regenerar_validator_output_json_por_serializer_e_reenviar_complete',
+      };
+    }
+  }
+
   if (packetResult.violations.length > 0) {
     return {
       gate: 'G4', action: 'complete', status: 'blocked', timestamp,
@@ -3543,7 +3670,7 @@ function toolsList() {
             run_id: { type: 'string', minLength: 1 },
             project_root: { type: 'string', minLength: 1 },
             artifact_path: { type: 'string', minLength: 1 },
-            artifact_kind: { enum: ['prd', 'plan'] },
+            artifact_kind: { enum: ['prd', 'plan', 'json'] },
           },
         },
       },
@@ -3593,7 +3720,7 @@ function toolsList() {
       },
       {
         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).',
+        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 só em modos com execução.',
         inputSchema: {
           type: 'object',
           additionalProperties: false,
@@ -3662,6 +3789,7 @@ function toolsList() {
             repair_run_id: { type: 'string' },
             dispatch_token: { type: 'integer' },
             challenge_response: { type: 'string' },
+            validator_output_path: { type: 'string' },
             verdict: { type: 'string', enum: ['pass', 'pass_with_observations', 'fail'] },
             data: { type: 'object', additionalProperties: true },
             host: { type: 'string', enum: HOST_NAMES },

package/hosts/opencode/.opencode/skills/_shared/references/stack-profiles.md

@@ -33,4 +33,40 @@ Ativação é determinística: inspecione manifests no boundary e comandos realm
 - parsing/typing nas fronteiras e mutabilidade de defaults;
 - `pytest`, `ruff`, `mypy` ou equivalente apenas se declarados.
 
+## Go — `go.mod` ou comando Go real
+
+- context propagation/cancelamento, goroutine leak, data race e cleanup;
+- erros retornados sem swallow, wrapping útil e validação em fronteiras;
+- `go test`, `go vet`, `go test -race` e linters somente quando declarados/aplicáveis.
+
+## Rust — `Cargo.toml` ou comando Cargo real
+
+- ownership/lifetime usados para segurança real, não wrappers desnecessários;
+- `Result`/`Option` tratados sem `unwrap`/`expect` em fronteiras recuperáveis;
+- `cargo test`, `cargo check`, `cargo clippy` e `cargo fmt` somente quando declarados/aplicáveis.
+
+## Java/Kotlin — Maven/Gradle ou comando Java/Kotlin real
+
+- nullability, exceptions, resource cleanup e lifecycle de threads/coroutines;
+- boundaries de DTO/entity, serialização e validação de input;
+- `mvn test`, `gradle test`, linters/typecheck somente quando declarados.
+
+## Firebase — `firebase.json`, `.firebaserc` ou dependência Firebase real
+
+- regras/claims/authz, paths e ownership de dados;
+- falhas offline/retry, listeners/subscriptions e cleanup;
+- emuladores/deploy/checks somente quando declarados.
+
+## Supabase — dependência Supabase real
+
+- RLS/auth claims, schema/migrations, RPC/Edge Functions e storage policies;
+- sessão/token refresh, SSR/cookies quando aplicável e boundaries de dados;
+- CLI/migration/testes somente quando declarados.
+
+## REST/OpenAPI — OpenAPI/Swagger ou servidor/cliente HTTP real
+
+- compatibilidade request/response, status codes, paginação, erros e idempotência;
+- validação runtime nas bordas e divergência entre contrato e implementação;
+- geração/validação OpenAPI somente quando declarada.
+
 Perfis podem coexistir em monorepo. Regra de perfil nunca vira finding fora do boundary onde seu sinal foi ativado.

package/hosts/opencode/.opencode/skills/_shared/scripts/document_quality.mjs

@@ -10,7 +10,11 @@ const VALID = Object.freeze({
   state: new Set(['backlog', 'ready', 'doing', 'review', 'done', 'blocked']),
 });
 
-const STACK_MANIFESTS = ['package.json', 'tsconfig.json', 'pubspec.yaml', 'pyproject.toml', 'requirements.txt', 'setup.py'];
+const STACK_MANIFESTS = [
+  'package.json', 'tsconfig.json', 'pubspec.yaml', 'pyproject.toml', 'requirements.txt', 'setup.py',
+  'go.mod', 'Cargo.toml', 'pom.xml', 'build.gradle', 'build.gradle.kts', 'settings.gradle', 'settings.gradle.kts',
+  'firebase.json', '.firebaserc', 'openapi.yaml', 'openapi.yml', 'openapi.json', 'swagger.yaml', 'swagger.yml', 'swagger.json',
+];
 
 function boundaryRoot(projectRoot, boundary) {
   const project = path.resolve(projectRoot);
@@ -47,6 +51,9 @@ function containsGetxImport(root) {
 
 function detectBoundaryProfile(root, declaredCommands) {
   const exists = (name) => fs.existsSync(path.join(root, name));
+  const readIfExists = (name) => {
+    try { return exists(name) ? fs.readFileSync(path.join(root, name), 'utf8') : ''; } catch { return ''; }
+  };
   const commands = declaredCommands.filter((v) => typeof v === 'string');
   let packageJson = null;
   if (exists('package.json')) {
@@ -57,13 +64,36 @@ function detectBoundaryProfile(root, declaredCommands) {
     try { pubspec = fs.readFileSync(path.join(root, 'pubspec.yaml'), 'utf8'); } catch {}
   }
   const packageCommands = Object.values(packageJson?.scripts ?? {}).filter((v) => typeof v === 'string');
+  const packageDeps = Object.keys({
+    ...(packageJson?.dependencies ?? {}),
+    ...(packageJson?.devDependencies ?? {}),
+    ...(packageJson?.peerDependencies ?? {}),
+    ...(packageJson?.optionalDependencies ?? {}),
+  });
+  const cargo = readIfExists('Cargo.toml');
+  const pom = readIfExists('pom.xml');
+  const gradle = `${readIfExists('build.gradle')}\n${readIfExists('build.gradle.kts')}\n${readIfExists('settings.gradle')}\n${readIfExists('settings.gradle.kts')}`;
   const allCommands = [...commands, ...packageCommands];
   const hasCommand = (re) => allCommands.some((command) => re.test(command));
+  const hasPackageDep = (re) => packageDeps.some((dep) => re.test(dep));
+  const javaKotlinSignal = exists('pom.xml') || exists('build.gradle') || exists('build.gradle.kts')
+    || exists('settings.gradle') || exists('settings.gradle.kts') || hasCommand(/\b(gradle|mvn|java|javac|kotlinc)\b/);
+  const restSignal = exists('openapi.yaml') || exists('openapi.yml') || exists('openapi.json')
+    || exists('swagger.yaml') || exists('swagger.yml') || exists('swagger.json')
+    || hasPackageDep(/\b(openapi|swagger|express|fastify|koa|hono|axios|ky)\b/i)
+    || /openapi|swagger|spring-boot-starter-web|ktor|retrofit/i.test(`${pom}\n${gradle}\n${pubspec}`);
   return {
     universal: true,
     flutter_dart: exists('pubspec.yaml') || hasCommand(/\b(flutter|dart)\b/),
     node_typescript: exists('package.json') || exists('tsconfig.json') || hasCommand(/\b(node|npm|pnpm|yarn|bun|tsc)\b/),
     python: exists('pyproject.toml') || exists('requirements.txt') || exists('setup.py') || hasCommand(/\b(python3?|pytest|ruff|mypy)\b/),
+    go: exists('go.mod') || hasCommand(/\bgo\s+(test|build|run|vet|fmt)\b/),
+    rust: exists('Cargo.toml') || hasCommand(/\bcargo\s+(test|build|run|check|clippy|fmt)\b/) || /^\s*\[package\]/m.test(cargo),
+    java_kotlin: javaKotlinSignal,
+    firebase: exists('firebase.json') || exists('.firebaserc') || hasPackageDep(/^firebase$|^@firebase\/|firebase-admin/i)
+      || /firebase_core|cloud_firestore|firebase_auth|firebase_messaging|firebase_storage/i.test(pubspec),
+    supabase: hasPackageDep(/^@supabase\/|supabase-js/i) || /supabase_flutter|supabase|postgrest/i.test(pubspec),
+    rest_openapi: restSignal,
     getx: /^\s{0,4}get\s*:/m.test(pubspec) || containsGetxImport(root),
   };
 }
@@ -80,6 +110,12 @@ export function detectStackProfiles(root, declaredCommands = [], boundaryPaths =
     flutter_dart: boundaries.some((profile) => profile.flutter_dart),
     node_typescript: boundaries.some((profile) => profile.node_typescript),
     python: boundaries.some((profile) => profile.python),
+    go: boundaries.some((profile) => profile.go),
+    rust: boundaries.some((profile) => profile.rust),
+    java_kotlin: boundaries.some((profile) => profile.java_kotlin),
+    firebase: boundaries.some((profile) => profile.firebase),
+    supabase: boundaries.some((profile) => profile.supabase),
+    rest_openapi: boundaries.some((profile) => profile.rest_openapi),
     getx: boundaries.some((profile) => profile.getx),
     boundaries,
   };