atlas-workflow 0.9.2 → 0.9.4

package/hosts/pi/skills/atlas-audit/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: atlas-audit
+description: Skill/mode universal de auditoria Atlas. Use para `/workflow audit <target>` com flags opcionais `--handoff` e `--scope <descrição>`. Audita código contra regras locais, boas práticas da stack detectada e complexidade acidental estilo Ponytail, sem corrigir código nem executar plano.
+---
+
+# Atlas Audit
+
+Auditoria universal, framework-agnóstica. Esta skill lê o repositório real, audita o `target` informado e entrega relatório de achados. Opcionalmente gera handoff Atlas-style para correção futura. **Nunca altera código. Nunca executa plano.**
+
+## Sintaxe
+
+```text
+/workflow audit <target>
+/workflow audit <target> --handoff
+/workflow audit <target> --scope <descrição>
+```
+
+`target` pode ser arquivo, diretório, pacote, módulo, feature, PRD/plano como referência ou descrição que aponte para um boundary localizável. Se não for possível resolver o boundary em disco, pare e peça um target mais preciso.
+
+## Contrato duro
+
+- Auditar o target informado, não o repo inteiro por padrão.
+- Diagnóstico factual vem antes de proposta de correção.
+- Todo achado precisa de evidência concreta `arquivo:linha`.
+- Não criar finding por preferência genérica sem evidência local.
+- Regras locais reais prevalecem sobre boas práticas genéricas.
+- Não migrar lógica especialista de Flutter/Dart para o core universal.
+- Adapters por stack/backend são opcionais; fallback universal deve funcionar.
+- Não inventar comandos de validação: usar apenas manifests/configs/scripts reais.
+- `--handoff` gera artefato de plano em `.atlas/plans/`, mas não chama executor.
+
+## Fluxo obrigatório
+
+1. **Resolver boundary**
+   - Identificar `project_root`, `target`, paths reais e exclusões óbvias (`node_modules`, `build`, `dist`, `.git`, caches).
+   - Se `--scope` existir, tratar como recorte adicional, não expansão automática para repo inteiro.
+   - Registrar limitações se parte do target estiver ausente, gerada ou ilegível.
+
+2. **Ler regras locais reais**
+   - Procurar e consultar, quando existirem e forem relevantes ao boundary: `AGENTS.md`, `CLAUDE.md`, `README.md`, docs de rules, `project-rules/`, configs de lint/format/typecheck/test, manifests e arquivos de workspace.
+   - Não copiar regras integralmente no relatório; listar só fontes consultadas e regras aplicáveis.
+
+3. **Detectar stack/perfis**
+   - Usar `../_shared/references/stack-profiles.md` como baseline.
+   - Detectar por manifests/configs/comandos reais, não só por extensão.
+   - Perfis esperados quando houver sinal: Dart/Flutter, TypeScript/Node, Python, Go, Rust, Java/Kotlin, Firebase, Supabase, REST/OpenAPI.
+   - Se múltiplos perfis coexistirem, aplicar cada regra só ao boundary onde o sinal foi ativado.
+
+4. **Entender arquitetura antes de julgar**
+   - Mapear camadas reais, fluxo de dados, contratos, entrypoints, DI, estado, side effects, testes e consumidores afetados.
+   - Comparar com padrões existentes do repo antes de classificar algo como violação.
+
+5. **Auditar por lentes**
+   - Arquitetura e ownership.
+   - Contrato/dados/schemas/mappers/DTOs.
+   - Erros, falhas parciais, retries, cleanup.
+   - Segurança, authz/authn, segredos, trust boundaries.
+   - Estado, concorrência, lifecycle, idempotência.
+   - Fluxos previstos e imprevistos.
+   - Testes e validação declarada.
+   - Observabilidade, logs e diagnóstico.
+   - Manutenção/DX.
+
+6. **Ponytail pass final**
+   - Procurar abstração inútil, wrapper sem valor, código morto, duplicação simples, dependência excessiva, branching/config acidental e complexidade que não protege segurança/contrato/dados.
+   - Só registrar se houver simplificação clara e segura, com evidência local.
+
+## Severidade
+
+- `P0`: quebra crítica, perda/corrupção de dados, bypass de segurança, execução impossível.
+- `P1`: bug provável em fluxo principal, contrato errado, regressão relevante, risco alto.
+- `P2`: gap importante, cenário não coberto, arquitetura frágil, teste/validação faltante com risco real.
+- `P3`: melhoria localizada, simplificação Ponytail, DX/manutenção, observação de baixo risco.
+
+## Formato do achado
+
+```md
+### AUDIT-001 — P1 — <categoria>
+- Arquivo: `path/to/file.ext:123`
+- Evidência: <fato observado no código>
+- Impacto: <falha/risco concreto>
+- Correção proposta: <direção, sem implementar>
+- Dependências/bloqueios: <se houver>
+- Status: `open`
+```
+
+Se não houver linha precisa, não promova a finding; registre em limitações ou perguntas.
+
+## Relatório de auditoria
+
+Responder em pt-BR com:
+
+```md
+# Auditoria Atlas — <target>
+
+## Stack detectada
+...
+
+## Regras locais consultadas
+...
+
+## Boundary auditado
+...
+
+## Achados
+### P0
+...
+### P1
+...
+### P2
+...
+### P3
+...
+
+## Gaps por área
+- Contrato/dados:
+- Segurança:
+- Testes:
+- Arquitetura:
+
+## Limitações
+...
+
+## Próximo passo seguro
+...
+```
+
+Se zero achados, diga explicitamente `Nenhum achado P0/P1/P2/P3 com evidência suficiente no boundary auditado` e liste risco residual/limitações.
+
+## `--handoff`
+
+Quando `--handoff` estiver presente, escrever em `.atlas/plans/PLAN_AUDIT_<slug>.md` um plano **conforme ao `PLAN_TEMPLATE.md` canônico** (resolver em `<raiz-do-plugin>/packages/templates/`), para que passe no gate TC (`atlas_verify_template_conformance`) e seja consumível por `/workflow execute plan <path>` ou por `atlas-plan-execute`. O plano só pode conter tasks derivadas dos achados evidenciados. Se a escrita falhar, reportar bloqueio e não fingir que há handoff executável.
+
+A auditoria **não tem PRD**: a fonte de verdade é o relatório de auditoria + achados + regras locais reais. O plano espelha o template, mas reancorado na auditoria — **sem inventar decisões `D*` nem referências PRD inexistentes**.
+
+### Cabeçalho obrigatório (gate TC)
+
+O gate TC exige literalmente a linha `| **PRD** |`, referência a `BOUNDARY_PRD_PLAN.md` e tarefas `#### T01.`. Em `execution_mode: sequencial`, a §7 Slices é dispensável.
+
+```md
+# PLAN AUDIT — <target> (correção de auditoria)
+
+| Campo | Valor |
+|-------|-------|
+| **PRD** | N/A — origem auditoria; ver **Source audit** abaixo |
+| **Package / app** | `<boundary auditado>` |
+| **Tipo** | `audit-fix` |
+| **execution_mode** | `sequencial (T01→TN)` |
+| **Data** | <YYYY-MM-DD> |
+
+**Escopo técnico:** boundary da auditoria. **Fora:** <o que ficou fora do target/scope>.
+
+Política: [BOUNDARY_PRD_PLAN.md](./BOUNDARY_PRD_PLAN.md).
+
+## Metadados de execução
+- Plan prefix: `atlas`
+- Execution mode: `sequencial (T01→TN)`
+- Executor skill: `atlas-plan-execute`
+- Internal validator: `atlas-task-validator`
+- Source audit: `<título/path/data do relatório>`
+```
+
+> `N/A — origem auditoria` satisfaz o regex do TC declarando a proveniência sem inventar PRD.
+
+### Seções obrigatórias (§1–§6, §8)
+
+Sem PRD, as âncoras "derivados do PRD" do template passam a apontar para achados/regras locais:
+
+- **§1 Tradução executiva** — 1 parágrafo do que será corrigido + resultado observável; referência ao relatório de auditoria.
+- **§2 Invariantes de execução** — invariantes derivados das regras locais reais e do boundary (não de `D*`).
+- **§3 Pitfalls** — anti-padrões evidenciados na auditoria → correção canônica.
+- **§4 Estado na abertura da sprint** — 3–6 bullets do que está quebrado hoje, ancorados nos achados.
+- **§5 Tarefas de execução** — `#### T01.`…`#### TNN.`, uma por achado evidenciado (schema abaixo).
+- **§6 Contratos técnicos** — só se a auditoria revelou contrato/dados/schema afetado; senão `Não aplicável`.
+- **§8 Validação e checklist (validator)** — comandos reais detectados (manifests/scripts) + checkboxes derivados dos achados. Nunca inventar `flutter`/`npm`/`pytest`.
+
+### Schema de cada task (§5)
+
+```md
+#### T01. <correção curta>
+- **Objetivo:** <resultado observável>
+- **Referência ao achado:** `AUDIT-NNN` — `arquivo:linha`
+- **Mudança esperada:** <o que muda concretamente>
+- **Invariantes preservados:** <§2 / regra local>
+- **Não mudar:** <…>
+- **Dependências:** <nenhuma | T0X>
+- **Riscos:** <se relevante>
+- **Critério de done:** <sinal objetivo>
+- **Validação local:**
+  ```bash
+  cd <package> && <comando real>
+  ```
+```
+
+### Regras do handoff
+
+- Incluir apenas validações derivadas de manifests/configs reais.
+- Não usar task vaga como "refatorar geral".
+- Não incluir achado sem `arquivo:linha`; toda task aponta para um `AUDIT-NNN`.
+- Não chamar executor automaticamente.
+- Reportar o path final do plano e deixar claro que ele não foi executado.

package/hosts/pi/skills/atlas-audit/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "Atlas Audit"
+  short_description: "Auditoria universal sem correção de código"
+  default_prompt: "Use $atlas-audit para auditar o target informado contra regras locais, stack detectada e Ponytail pass, sem alterar código."
+
+policy:
+  allow_implicit_invocation: true

package/hosts/pi/skills/atlas-task-validator/SKILL.md

@@ -102,6 +102,12 @@ Ative regras específicas somente quando o perfil retornar `true`:
 - `flutter_dart`: lifecycle Flutter, rotas/args, null-safety/casts, l10n, analyze/test; GetX somente se dependência/import/regra real confirmar GetX.
 - `node_typescript`: handles/promises, validação runtime, ESM/CJS/exports/tipos e scripts Node reais.
 - `python`: context managers/cleanup, exceções/async, typing/parsing e ferramentas Python declaradas.
+- `go`: context/cancelamento, goroutines, erros retornados, data race e comandos Go declarados.
+- `rust`: `Result`/`Option`, ownership/lifetime, unwrap em fronteiras recuperáveis e comandos Cargo declarados.
+- `java_kotlin`: nullability, exceptions, resource cleanup, threads/coroutines e Maven/Gradle declarados.
+- `firebase`: rules/claims/authz, paths/ownership, listeners e emuladores/checks declarados.
+- `supabase`: RLS/auth claims, schema/migrations, RPC/Edge Functions, storage policies e checks declarados.
+- `rest_openapi`: request/response, status codes, paginação, erros, idempotência e contrato OpenAPI quando presente.
 
 Monorepo pode ativar múltiplos perfis, sempre restritos ao boundary correspondente. Fixture Node sem sinal Flutter não recebe regra Flutter/GetX.
 

package/hosts/pi/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/zcode/.zcode-plugin/plugin.json

@@ -0,0 +1,27 @@
+{
+  "name": "atlas-workflow-orchestrator",
+  "version": "0.9.4",
+  "description": "Orquestra pipelines de desenvolvimento de features no Atlas (PRD, validação, entrevista, plano, execução, repair, review), auditoria universal e geração explícita de backlog mestre. Bundle único: 10 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.