atlas-workflow 0.9.3 → 0.9.4

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,
   };

package/hosts/opencode/.opencode/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/opencode/.opencode/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/opencode/.opencode/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/opencode/.opencode/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?".
@@ -138,8 +145,10 @@ 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.
@@ -184,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
 
@@ -233,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
@@ -330,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) |
 |-------|---------|------------------|
@@ -338,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/pi/atlas/VERSION

@@ -1 +1 @@
-0.9.3
+0.9.4

package/hosts/pi/atlas/orchestrator/README.md

@@ -222,9 +222,15 @@ Veja este README, `packages/mcp-server/README.md` e os SKILL.md `atlas-*` para o
 
 ---
 
-**Plugin version:** 0.9.3
+**Plugin version:** 0.9.4
 **Author:** Paulo Borini
-**Last updated:** 2026-06-16
+**Last updated:** 2026-06-27
+
+### Novidades v0.9.4 — audit handoff TC-conforme + perfis de stack
+
+- `/workflow audit --handoff` passa a escrever `.atlas/plans/PLAN_AUDIT_<slug>.md` **conforme ao `PLAN_TEMPLATE.md`** (cabeçalho com `| **PRD** | N/A — origem auditoria |`, ref a `BOUNDARY_PRD_PLAN.md`, §1–§6/§8, tasks `#### T01.`): passa no gate TC e é de fato consumível por `/workflow execute plan`. Fecha a promessa quebrada da estrutura ad-hoc anterior, que falharia o gate.
+- Perfis de stack ganham 6 linhas detectáveis — `go`, `rust`, `java_kotlin`, `firebase`, `supabase`, `rest_openapi` — no baseline universal e no validador frio, ativadas só por manifests/deps/comandos reais no boundary.
+- `audit`/`interview-only` não declaram `guarantee_level` (não há execução a garantir); descrição do `atlas_preflight` endurecida para refletir a impl.
 
 ### Novidades v0.8.4 — liveness do executor (Gate G12)
 
@@ -268,3 +274,10 @@ Veja este README, `packages/mcp-server/README.md` e os SKILL.md `atlas-*` para o
 - Os únicos sub-agents do pipeline são `atlas-plan-execute`/`atlas-direct-execute`, `atlas-task-validator`, `atlas-findings-repair` e `atlas-slice-review`.
 - A topologia é **sibling** em todos os hosts: o orquestrador coordena o validator irmão a partir do `state_path` retornado pelo executor e só reabre execução em `fail`. Host sem join síncrono é rejeitado no preflight (gate JOIN).
 - `atlas_preflight`/dispatchability distinguem skills documentais de skills executoras, evitando exigir sub-agent para entrevista/plano.
+
+### Novidades v0.9.3 — ZCode como novo host (tier-1)
+
+- **Novo host: ZCode** (Claude Agent SDK compat). Entrada `zcode` em `HOST_ADAPTERS` (`packages/mcp-server/server.js`) com perfil `self_evident` — `Agent(subagent_type)` + `TodoWrite` + MCP stdio + skills nativas, clone estrutural do Claude Code. Detector `ZCODE_PLUGIN_ROOT` em `HOST_DETECTORS`. `validator_dispatch.join.sync: 'self_evident'`, `confidence: 'presumed'`.
+- ZCode reusa o agente canônico `agents/<name>.md` no plugin root (mesmo formato Claude); sem gerador próprio, sem custo de manutenção a cada nova skill/agent.
+- Installer `init zcode` (cache-based, análogo ao `init antigravity`): copia catálogo `hosts/zcode/` para `~/.zcode/cli/plugins/cache/zcode-plugins-official/atlas-workflow-orchestrator/<version>/` e atualiza o `marketplace.json` cache. Ativação no app via `/plugins enable atlas-workflow-orchestrator`. **Sem dependências externas** (não exige `pi-mcp-adapter`/etc. — passa no preflight direto).
+- Sete hosts suportados: `claude`, `codex`, `opencode`, `pi`, `antigravity`, `zcode`, `generic`. `CAPABILITIES_SCHEMA_VERSION` segue **v5** (adição aditiva, sem breaking). Smoke real no host ZCode confirma `host=zcode sv=5 join.sync=self_evident ping=alive version=0.9.3`.

package/hosts/pi/atlas/orchestrator/commands/workflow.md

@@ -1,6 +1,6 @@
 ---
-description: Orquestra pipeline de desenvolvimento de feature no Atlas (PRD → validação → entrevista → plano → execução → review)
-argument-hint: <mode> <input-type> [input] [--interview] [--review] [--help]
+description: Orquestra pipeline de desenvolvimento de feature no Atlas (PRD → validação → entrevista → plano → execução → review) e auditoria universal sem correção
+argument-hint: <mode> <input-type|target> [input] [--interview] [--review] [--handoff] [--scope] [--help]
 ---
 
 Você está executando o comando `/workflow` do plugin **atlas-workflow-orchestrator**.
@@ -16,12 +16,12 @@ Argumentos recebidos: `$ARGUMENTS`
 ## Referência rápida de sintaxe
 
 ```
-/workflow <mode> <input-type> [input] [flags]
+/workflow <mode> <input-type|target> [input] [flags]
 ```
 
-- **mode**: `full` · `direct` · `execute` · `interview-only`
+- **mode**: `full` · `direct` · `execute` · `interview-only` · `audit`
 - **input-type**: `backlog-item` · `idea` · `prd` · `plan` · `brainstorm`
-- **flags**: `--interview` · `--review` · `--help`
+- **flags**: `--interview` · `--review` · `--handoff` · `--scope <descrição>` · `--help`
 
 Exemplos:
 
@@ -30,6 +30,8 @@ Exemplos:
 /workflow direct prd "/path/PRD_S05.md" --review
 /workflow execute plan "/path/PLAN_S05.md"
 /workflow interview-only brainstorm "que tal dark mode?"
+/workflow audit apps/mobile/lib/features/auth --handoff
+→ Gera relatório e `.atlas/plans/PLAN_AUDIT_*.md`; não executa correções
 ```
 
 Não improvise comportamento fora do `SKILL.md`. **Pipeline é fire-and-continue**: uma vez iniciado, avança fase a fase sem pedir permissão entre gates; só para em gate duro `blocked` ou blockage de ambiente real (ver "Princípio de continuação automática"). Nunca invente "Modo Discussão" ou peça "quer que eu gere/continue?". Decisão em aberto não para — dispara entrevista, propaga e segue. Em caso de erro real, siga "Error handling".

package/hosts/pi/atlas/orchestrator/references/subagent_dispatch.md

@@ -1,6 +1,6 @@
 # Despacho de sub-agent
 
-Contrato host-agnóstico para Cursor, Codex e Claude Code.
+Contrato host-agnóstico para Claude Code, Cursor, Codex App, Antigravity, ZCode, OpenCode e Pi CLI.
 
 ## Regra central
 
@@ -26,6 +26,16 @@ spawn_agent(agent_type: "atlas-task-validator", items: [{ type: "text", text: "<
 
 O registro ativo desse agent vive em `CODEX_HOME/agents/atlas-task-validator.toml` após `npx github:pauloborini/atlas-workflow init codex`; o bundle mantém `.codex/agents/` como fonte gerada. O arquivo é gerado por `build/gen-host-agent.mjs` com `model = "gpt-5.4"` e `model_reasoning_effort = "high"`. Se o host responder `unknown agent_type`, a fase bloqueia (`blocked`/fail-closed). Proibido fallback para `default`, `$atlas-task-validator`, execução inline ou validação no fio do orquestrador.
 
+## ZCode
+
+ZCode é Claude Agent SDK compat (clone estrutural do Claude Code). O mecanismo de sub-agent é o **mesmo** do Claude:
+
+```text
+Agent(subagent_type: "atlas-task-validator", prompt: "<state_path>")
+```
+
+O registro ativo do agent vive em `agents/<name>.md` na raiz do plugin (mesmo formato Claude, sem geração extra), descoberto pelo host via `.zcode-plugin/plugin.json` (skills + agents do plugin). O ZCode injeta `ZCODE_PLUGIN_ROOT` no env do subprocesso MCP (verificado no bundle `zcode.cjs`). Após `npx github:pauloborini/atlas-workflow init zcode`, o catálogo `hosts/zcode/` é copiado para `~/.zcode/cli/plugins/cache/zcode-plugins-official/atlas-workflow-orchestrator/<version>/` e ativado no app via `/plugins enable atlas-workflow-orchestrator`. ZCode é `self_evident` (passa PREREQ/JOIN sem report), sem dependências externas.
+
 ## Payload mínimo
 
 - `skill_id`