atlas-workflow 0.9.2 → 0.9.4

package/README.md

@@ -1,8 +1,8 @@
 # Atlas Workflow
 
-Plugin **Atlas Workflow Orchestrator** v0.9.1 — pipeline determinístico (PRD → plano → execução → validação) com skills `atlas-*`, templates e MCP. Um pacote, seis hosts: **Claude Code**, **Cursor**, **Codex App**, **Antigravity (Gemini)**, **OpenCode** e **Pi CLI**.
+Plugin **Atlas Workflow Orchestrator** v0.9.4 — pipeline determinístico (PRD → plano → execução → validação) com skills `atlas-*`, templates e MCP. Um pacote, sete hosts: **Claude Code**, **Cursor**, **Codex App**, **Antigravity (Gemini)**, **ZCode**, **OpenCode** e **Pi CLI**.
 
-**Versão:** [`VERSION`](VERSION) (`0.9.1`) · **Repo:** https://github.com/pauloborini/atlas-workflow
+**Versão:** [`VERSION`](VERSION) (`0.9.4`) · **Repo:** https://github.com/pauloborini/atlas-workflow
 
 ## Hosts
 
@@ -12,6 +12,7 @@ Plugin **Atlas Workflow Orchestrator** v0.9.1 — pipeline determinístico (PRD
 | Cursor | **Igual ao Claude Code** (ver nota abaixo) | `atlas-workflow-claude.plugin` | — |
 | Codex App | Marketplace GitHub | `atlas-workflow-codex.plugin` | — |
 | Antigravity (Gemini) | Instalador from-source (`init antigravity`) → `~/.gemini/config/` | — (cópia direta, sem artefato `.plugin`) | — |
+| ZCode | Instalador cache-based (`init zcode`) → `~/.zcode/cli/plugins/cache/` | `atlas-workflow-zcode.plugin` | — |
 | Opencode | Catálogo from-source `hosts/opencode/` | `atlas-workflow-opencode.plugin` | — |
 | Pi CLI | Catálogo from-source `hosts/pi/` | `atlas-workflow-pi.plugin` | **`pi-mcp-adapter` + `pi-subagents`** |
 
@@ -31,6 +32,7 @@ Um instalador único cobre os hosts de forma **global** (recomendado para valer
 npx github:pauloborini/atlas-workflow init claudecode   # ou: cursor
 npx github:pauloborini/atlas-workflow init codex
 npx github:pauloborini/atlas-workflow init antigravity
+npx github:pauloborini/atlas-workflow init zcode
 npx github:pauloborini/atlas-workflow init opencode --global
 npx github:pauloborini/atlas-workflow init pi --global --yes  # --yes auto-instala as 2 deps
 ```
@@ -38,6 +40,7 @@ npx github:pauloborini/atlas-workflow init pi --global --yes  # --yes auto-insta
 - **claudecode/cursor**: o instalador roda o `marketplace add` + `install` nativos da CLI por você. Já são globais por natureza.
 - **codex**: o instalador roda `marketplace add` + `plugin add` e também copia os custom agents Atlas para `CODEX_HOME/agents` (`~/.codex/agents` se `CODEX_HOME` não estiver definido). Este é o caminho garantido para `spawn_agent(agent_type: "atlas-*")`.
 - **antigravity**: o instalador registra o Atlas como um plugin em `~/.gemini/config/plugins/` e adiciona o MCP correspondente em `mcp_config.json`.
+- **zcode**: o instalador copia o catálogo from-source `hosts/zcode/` para `~/.zcode/cli/plugins/cache/zcode-plugins-official/atlas-workflow-orchestrator/<version>/` e atualiza o `marketplace.json` cache. Ative no host via `/plugins enable atlas-workflow-orchestrator`. ZCode é Claude Agent SDK (clone estrutural do Claude Code): `Agent(subagent_type)` + `TodoWrite` + MCP stdio nativos — perfil `self_evident`, sem dependências externas.
 - **opencode**: com `--global`, instala globalmente em `~/.config/opencode/` (o MCP é registrado com caminho absoluto, funcionando em todos os projetos).
 - **pi**: com `--global`, instala globalmente em `~/.pi/agent/` (honra `PI_CODING_AGENT_DIR`), registra o MCP em `mcp.json` global e checa/instala as deps `pi-mcp-adapter` + `pi-subagents`.
 
@@ -86,6 +89,7 @@ Se a instalação foi **global** (padrão recomendado):
 ```bash
 npx github:pauloborini/atlas-workflow uninstall claudecode   # ou: cursor
 npx github:pauloborini/atlas-workflow uninstall codex
+npx github:pauloborini/atlas-workflow uninstall zcode
 npx github:pauloborini/atlas-workflow uninstall opencode --global
 npx github:pauloborini/atlas-workflow uninstall pi --global
 ```
@@ -100,15 +104,15 @@ npx github:pauloborini/atlas-workflow uninstall pi
 
 ## Artefato `.plugin` (opcional)
 
-Alternativa à instalação via GitHub: baixar o `.plugin` do host (`claude`, `codex`, `opencode` ou `pi`) na [release](https://github.com/pauloborini/atlas-workflow/releases) (tags `v*`), validar com `shasum -a 256 -c SHA256SUMS` e instalar pelo fluxo do host. Cursor usa o artefato Claude.
+Alternativa à instalação via GitHub: baixar o `.plugin` do host (`claude`, `codex`, `opencode`, `pi` ou `zcode`) na [release](https://github.com/pauloborini/atlas-workflow/releases) (tags `v*`), validar com `shasum -a 256 -c SHA256SUMS` e instalar pelo fluxo do host. Cursor usa o artefato Claude.
 
 ## Como usar
 
 Comando (Claude Code / Cursor): `/workflow <mode> <input-type> [input] [flags]`
 
-No Codex, opencode e pi, invoque a skill do orquestrador com o mesmo padrão de argumentos (ex.: `workflow full backlog-item S05`). O verbo de dispatch do subagente é resolvido por `atlas_capabilities` (host-agnóstico).
+No Codex, opencode, pi e zcode, invoque a skill do orquestrador com o mesmo padrão de argumentos (ex.: `workflow full backlog-item S05`). O verbo de dispatch do subagente é resolvido por `atlas_capabilities` (host-agnóstico).
 
-Se você quiser começar fora do fluxo principal, as skills listadas abaixo são os atalhos explícitos para backlog, PRD, plano, execução e revisão.
+Se você quiser começar fora do fluxo principal, as skills listadas abaixo são os atalhos explícitos para backlog, PRD, auditoria, plano, execução e revisão.
 
 ### Modos
 
@@ -118,8 +122,9 @@ Se você quiser começar fora do fluxo principal, as skills listadas abaixo são
 | **`direct`** | PRD já existe e está maduro | Valida PRD → entrevista só se houver gap → **executa direto** (sem fase de plan handoff) → review opcional |
 | **`execute`** | Já tenho um `PLAN_*.md` pronto | Reverifica o plano (artefato + conformidade) → **executa o plano existente** → review opcional. **Não regera plano.** |
 | `interview-only` | Só fechar decisões / brainstorm | Entrevista; não implementa |
+| **`audit`** | Quero diagnóstico sem patch | Audita target/boundary contra regras locais + stack detectada + Ponytail pass; `--handoff` grava `.atlas/plans/PLAN_AUDIT_*.md` sem executar |
 
-**Dica:** `full` = “quero PRD + plano + código”. `direct` = “já tenho PRD aprovado, implementa”. `execute` = “já tenho o plano, só executa”.
+**Dica:** `full` = “quero PRD + plano + código”. `direct` = “já tenho PRD aprovado, implementa”. `execute` = “já tenho o plano, só executa”. `audit` = “diagnostica, não corrige”.
 
 > **Roteamento por tipo de input (v0.4.1+):** o tipo do arquivo que você passa **prevalece** sobre o modo digitado. Apontar um `PLAN_*.md` em `direct`/`full` (mesmo renomeado) auto-roteia para `execute` com um aviso de uma linha — nunca gera “plano de plano”. Pedir `execute` sobre um backlog/PRD roteia de volta para `full`/`direct`.
 
@@ -129,6 +134,7 @@ Se você quiser começar fora do fluxo principal, as skills listadas abaixo são
 - `idea` — indicação curta em texto
 - `prd` — caminho para `PRD_*.md` existente (principal em **`direct`**)
 - `plan` — caminho para `PLAN_*.md` existente (principal em **`execute`**)
+- `target` — arquivo/diretório/feature/módulo auditável (só em **`audit`**)
 - `brainstorm` — texto livre (só com `interview-only`)
 
 ### Flags
@@ -185,7 +191,9 @@ Só alinhar decisões antes de planejar:
 
 ### Skills da cadeia
 
-Cadeia automática: `atlas-sprint-prd-generator` → `atlas-prd-interview` → `atlas-plan-handoff` → `atlas-plan-execute` (full) ou `atlas-direct-execute` (direct) → `atlas-task-validator` → `atlas-findings-repair` (só após `fail`, em qualquer host) → `atlas-slice-review` (opcional)
+Cadeia automática de execução: `atlas-sprint-prd-generator` → `atlas-prd-interview` → `atlas-plan-handoff` → `atlas-plan-execute` (full) ou `atlas-direct-execute` (direct) → `atlas-task-validator` → `atlas-findings-repair` (só após `fail`, em qualquer host) → `atlas-slice-review` (opcional)
+
+Modo sem execução: `atlas-audit` roda no fio principal, não altera código, não chama executor e pode gravar handoff Atlas-style em `.atlas/plans/` com `--handoff`.
 
 No modo `full`, as etapas documentais (`PRD`, entrevista, `PLAN_*.md`) ficam no agente principal/orquestrador. O primeiro sub-agent obrigatório nasce só na fase de execução (`atlas-plan-execute`).
 
@@ -196,6 +204,7 @@ Além da cadeia automática, estas skills também podem ser chamadas diretamente
 - `atlas-backlog-generator` — cria `BACKLOG_MESTRE_*.md` a partir de uma conversa, briefing, roadmap ou lista solta de requisitos. Use quando o objetivo for organizar demanda antes de virar PRD.
 - `atlas-sprint-prd-generator` — transforma um sprint ID como `S01`/`S02` em PRD de sprint. Use quando o escopo já está amarrado ao roadmap e você quer o PRD da rodada.
 - `atlas-prd-interview` — valida e amadurece um PRD antes de planejar. Use quando você quer fechar ambiguidades, dependências ou decisões de produto.
+- `atlas-audit` — audita um target sem corrigir código. Use quando você quer achados com evidência `arquivo:linha` e, opcionalmente, handoff para correção posterior.
 - `atlas-plan-handoff` — converte um PRD validado em plano executável. Use quando a intenção é preparar a execução, não ainda codar.
 - `atlas-direct-execute` — executa diretamente quando o PRD já está maduro. Use quando você quer pular a fase de plan handoff.
 - `atlas-task-validator` — faz a validação fria da slice executada. Use como veredito final de conformidade, nunca como ação manual de rotina.
@@ -224,8 +233,8 @@ O validador frio (`atlas-task-validator`) **sempre** roda isolado e **sempre** c
 | [`packages/`](packages/) | Skills, templates, MCP |
 | [`agents/`](agents/) | Subagentes despachados (Claude): `atlas-task-validator`, `atlas-plan-execute`, `atlas-direct-execute`, `atlas-slice-review` |
 | [`plugins/atlas-workflow-orchestrator/`](plugins/atlas-workflow-orchestrator/) | Catálogo Codex from-source (marketplace) |
-| [`hosts/opencode/`](hosts/opencode/) · [`hosts/pi/`](hosts/pi/) | Catálogos from-source opencode/pi |
-| [`plugin-manifests/`](plugin-manifests/) | Manifests/configs por host (claude, codex, opencode, pi) |
+| [`hosts/opencode/`](hosts/opencode/) · [`hosts/pi/`](hosts/pi/) · [`hosts/zcode/`](hosts/zcode/) | Catálogos from-source opencode/pi/zcode |
+| [`plugin-manifests/`](plugin-manifests/) | Manifests/configs por host (claude, codex, opencode, pi, zcode) |
 | [`build/`](build/) | Gera `.plugin` em `dist/`, sincroniza catálogos, testes/smoke/conformance |
 | [`CHANGELOG.md`](CHANGELOG.md) · [`PATCH_PROCEDURE.md`](PATCH_PROCEDURE.md) | Release e manutenção |
 

package/VERSION

@@ -1 +1 @@
-0.9.2
+0.9.4

package/build/bump-version.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-// Bump determinístico de versão. Sincroniza os arquivos com versão concreta,
-// regenera bundles/catálogos e roda check-consistency. NÃO cria tag nem commita
-// — quem publica é o workflow Release ao detectar VERSION novo na main.
+// Bump deterministico de versao. Sincroniza os arquivos com versao concreta,
+// regenera bundles/catalogos e roda check-consistency. NAO cria tag nem commita
+// — quem publica e cria a tag é o workflow Release ao detectar VERSION novo na main.
 //
 // Uso: node build/bump-version.mjs <nova-versao>   (ex.: 0.8.3)
 //
@@ -88,26 +88,11 @@ execFileSync('bash', [path.join(ROOT, 'build', 'build-plugins.sh')], { cwd: ROOT
 console.log(`Rodando check-consistency…`);
 execFileSync('node', [path.join(ROOT, 'build', 'check-consistency.mjs')], { cwd: ROOT, stdio: 'inherit' });
 
-// Criar tag git local (marketplace resolve por tag, não por HEAD).
-// Tag só é criada — push fica pro passo manual junto com o commit.
-// CI Release é idempotente: se tag já existe, pula criação.
-const tag = `v${next}`;
-try {
-  execFileSync('git', ['tag', tag], { cwd: ROOT, stdio: 'pipe' });
-  console.log(`\n  tag   ${tag} (local — push com: git push origin ${tag})`);
-} catch (e) {
-  if (e.stderr?.toString().includes('already exists')) {
-    console.log(`\n  tag   ${tag} já existe (ok)`);
-  } else {
-    throw e;
-  }
-}
-
 console.log(`\nbump-version: ${current} -> ${next} OK.
 
 Passos narrativos manuais (não automatizáveis):
   1. CHANGELOG.md — adicionar entrada "## ${next} - YYYY-MM-DD".
   2. packages/orchestrator/README.md — adicionar seção "### Novidades v${next}" e "Last updated".
-  3. Revisar 'git status', commitar e dar push na main (incluir tag):
-       git push origin main v${next}
-     => CI Release detecta tag existente e publica sem re-criar.`);
+  3. Revisar 'git status', commitar e dar push na main:
+       git push origin main
+     => CI Release publica e cria a tag v${next}.`);

package/build/cli/atlas-init.mjs

@@ -31,6 +31,7 @@ const HOST_ALIASES = {
   codex: 'codex',
   opencode: 'opencode',
   pi: 'pi',
+  zcode: 'zcode', zai: 'zcode',
   antigravity: 'antigravity', gemini: 'antigravity', antigravitycode: 'antigravity',
 };
 
@@ -571,6 +572,91 @@ function uninstallAntigravity(opts) {
   log('ok — artefatos globais do Atlas para Antigravity removidos.');
 }
 
+// --- ZCode (cache-based install) ----------------------------------------------
+// ZCode só descobre plugins no escopo `zcode-plugins-official` (verificado
+// empiricamente no bundle zcode.cjs: `G2="zcode-plugins-official"` é hardcoded e o
+// scan de cache é restrito a `cache/zcode-plugins-official/<plugin>/<version>/`).
+// Por isso o installer copia para esse path — não para um marketplace custom.
+// O ZCode também regenera `marketplaces/zcode-plugins-official/marketplace.json` no
+// boot a partir do scan; mantemos essa entry sincronizada para visualização imediata.
+
+const ZCODE_MARKETPLACE = 'zcode-plugins-official';
+const ZCODE_PLUGIN_NAME = 'atlas-workflow-orchestrator';
+
+function zcodeCacheDir() {
+  return path.join(homedir(), '.zcode', 'cli', 'plugins', 'cache', ZCODE_MARKETPLACE, ZCODE_PLUGIN_NAME, VERSION);
+}
+
+function zcodeMarketplaceCacheFile() {
+  return path.join(homedir(), '.zcode', 'cli', 'plugins', 'marketplaces', ZCODE_MARKETPLACE, 'marketplace.json');
+}
+
+function updateZcodeMarketplaceCacheEntry(cacheDir) {
+  const file = zcodeMarketplaceCacheFile();
+  let cfg = { name: ZCODE_MARKETPLACE, plugins: [], version: 1 };
+  if (fs.existsSync(file)) {
+    try { cfg = JSON.parse(fs.readFileSync(file, 'utf8')); }
+    catch { log(`  aviso: ${path.basename(file)} é JSON inválido — reescrevendo do zero`); }
+  }
+  cfg.name = ZCODE_MARKETPLACE;
+  cfg.plugins = (cfg.plugins ?? []).filter((p) => p.name !== ZCODE_PLUGIN_NAME);
+  cfg.plugins.push({ cachePath: cacheDir, name: ZCODE_PLUGIN_NAME, source: 'filesystem', version: VERSION });
+  cfg.version = 1;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(cfg, null, 2) + '\n');
+}
+
+function removeZcodeMarketplaceCacheEntry() {
+  const file = zcodeMarketplaceCacheFile();
+  if (!fs.existsSync(file)) return;
+  try {
+    const cfg = JSON.parse(fs.readFileSync(file, 'utf8'));
+    cfg.plugins = (cfg.plugins ?? []).filter((p) => p.name !== ZCODE_PLUGIN_NAME);
+    fs.writeFileSync(file, JSON.stringify(cfg, null, 2) + '\n');
+  } catch { log(`  aviso: ${path.basename(file)} é JSON inválido — não mexi`); }
+}
+
+function installZcode(opts) {
+  const cacheDir = zcodeCacheDir();
+  const catalogSrc = path.join(ROOT, 'hosts/zcode');
+  log(`instalando Atlas (zcode v${VERSION}) GLOBAL em ${cacheDir}`);
+  if (!fs.existsSync(catalogSrc)) fail(`catálogo zcode ausente: hosts/zcode/ (rode build/build-plugins.sh)`);
+  if (opts.dryRun) {
+    log(`  [dry-run] copiaria hosts/zcode/ → ${cacheDir}`);
+    log(`  [dry-run] atualizaria ${zcodeMarketplaceCacheFile()}`);
+    return;
+  }
+  // Limpa instalação anterior (pode haver versão stale)
+  const parentDir = path.dirname(cacheDir);
+  if (fs.existsSync(parentDir)) fs.rmSync(parentDir, { recursive: true, force: true });
+  fs.mkdirSync(cacheDir, { recursive: true });
+  fs.cpSync(catalogSrc, cacheDir, { recursive: true });
+  // Gera o seed file no formato que o ZCode espera
+  const seed = {
+    hash: '',
+    marketplace: ZCODE_MARKETPLACE,
+    plugin: ZCODE_PLUGIN_NAME,
+    pluginVersion: VERSION,
+    source: 'filesystem',
+    version: 1,
+  };
+  fs.writeFileSync(path.join(cacheDir, '.zcode-plugin-seed.json'), JSON.stringify(seed, null, 2) + '\n');
+  // Sincroniza a entry do marketplace cache (o ZCode regenera no boot, mas
+  // mantemos sincronizado para visualização imediata no `/plugins`).
+  updateZcodeMarketplaceCacheEntry(cacheDir);
+  log('ok — ZCode instalado no cache oficial.');
+  log('próximo: abra o ZCode e ative via /plugins enable atlas-workflow-orchestrator');
+  log('  confirme com a tool MCP atlas_ping (host=zcode, status=alive).');
+}
+
+function uninstallZcode(opts) {
+  const cacheParent = path.join(homedir(), '.zcode', 'cli', 'plugins', 'cache', ZCODE_MARKETPLACE, ZCODE_PLUGIN_NAME);
+  log(`removendo Atlas (zcode) GLOBAL de ${cacheParent}`);
+  rmIfExists(cacheParent, opts);
+  removeZcodeMarketplaceCacheEntry();
+  log('ok — ZCode: cache e registry removidos.');
+}
+
 function usage() {
   log(`atlas-workflow v${VERSION} — instalador multi-host
 
@@ -582,6 +668,7 @@ hosts:
   claudecode | cursor   via \`claude plugin\` (marketplace from-source; já global)
   codex                 via \`codex plugin\` + custom agents em CODEX_HOME/agents
   antigravity           via plugin nativo em ~/.gemini/config/ (já global)
+  zcode                 via cache ~/.zcode/cli/plugins/cache/ (já global; /plugins enable)
   opencode              por-projeto: .opencode/ + opencode.json no [dir]
                         --global: ~/.config/opencode/ (vale em todos os projetos)
   pi                    por-projeto: .mcp.json + .pi/agents/ no [dir] + deps
@@ -636,23 +723,23 @@ function main() {
     fail(`comando desconhecido: ${cmd} (use \`init <host>\` ou \`uninstall <host>\`)`, 2);
   }
 
-  if (!rawHost) fail('informe o host: claudecode | cursor | codex | antigravity | opencode | pi', 2);
+  if (!rawHost) fail('informe o host: claudecode | cursor | codex | antigravity | zcode | opencode | pi', 2);
   if (extra.length) fail(`argumentos extras não suportados: ${extra.join(' ')}`, 2);
   const host = HOST_ALIASES[rawHost.toLowerCase()];
-  if (!host) fail(`host inválido: ${rawHost} (use claudecode|cursor|codex|antigravity|opencode|pi)`, 2);
+  if (!host) fail(`host inválido: ${rawHost} (use claudecode|cursor|codex|antigravity|zcode|opencode|pi)`, 2);
 
   const opts = parsed.opts;
   const targetDir = path.resolve(opts.dir || rawDir || process.cwd());
   const actions = {
-    init: { claude: installClaude, codex: installCodex, antigravity: installAntigravity, opencode: installOpencode, pi: installPi },
-    uninstall: { claude: uninstallClaude, codex: uninstallCodex, antigravity: uninstallAntigravity, opencode: uninstallOpencode, pi: uninstallPi },
+    init: { claude: installClaude, codex: installCodex, antigravity: installAntigravity, zcode: installZcode, opencode: installOpencode, pi: installPi },
+    uninstall: { claude: uninstallClaude, codex: uninstallCodex, antigravity: uninstallAntigravity, zcode: uninstallZcode, opencode: uninstallOpencode, pi: uninstallPi },
   };
   const globalActions = {
     init: { opencode: installOpencodeGlobal, pi: installPiGlobal },
     uninstall: { opencode: uninstallOpencodeGlobal, pi: uninstallPiGlobal },
   };
 
-  if (host === 'claude' || host === 'codex' || host === 'antigravity') {
+  if (host === 'claude' || host === 'codex' || host === 'antigravity' || host === 'zcode') {
     if (opts.global && (host === 'claude' || host === 'codex')) log('nota: claude/codex já são globais por natureza (registro da CLI) — --global ignorado.');
     actions[cmd][host](opts);
   } else if (opts.global) {

package/build/tests/etapa3.test.mjs

@@ -38,18 +38,48 @@ test('perfis: Flutter, Node e Python ativam só regras aplicáveis', () => {
     for (const [file, content] of Object.entries(files)) fs.writeFileSync(path.join(dir, file), content);
     return detectStackProfiles(dir, commands);
   };
-  assert.deepEqual(fixture('node', { 'package.json': '{"scripts":{"test":"node --test"}}' }).boundaries[0], {
-    boundary: '.', universal: true, flutter_dart: false, node_typescript: true, python: false, getx: false,
+  assert.deepEqual(pickProfile(fixture('node', { 'package.json': '{"scripts":{"test":"node --test"}}' }).boundaries[0]), {
+    boundary: '.', flutter_dart: false, node_typescript: true, python: false, go: false, rust: false, java_kotlin: false,
+    firebase: false, supabase: false, rest_openapi: false, getx: false,
   });
-  assert.deepEqual(fixture('flutter', { 'pubspec.yaml': 'name: fixture\ndependencies:\n  flutter:\n    sdk: flutter\n' }).boundaries[0], {
-    boundary: '.', universal: true, flutter_dart: true, node_typescript: false, python: false, getx: false,
+  assert.deepEqual(pickProfile(fixture('flutter', { 'pubspec.yaml': 'name: fixture\ndependencies:\n  flutter:\n    sdk: flutter\n' }).boundaries[0]), {
+    boundary: '.', flutter_dart: true, node_typescript: false, python: false, go: false, rust: false, java_kotlin: false,
+    firebase: false, supabase: false, rest_openapi: false, getx: false,
   });
-  assert.deepEqual(fixture('python', { 'pyproject.toml': '[project]\nname="fixture"\n' }).boundaries[0], {
-    boundary: '.', universal: true, flutter_dart: false, node_typescript: false, python: true, getx: false,
+  assert.deepEqual(pickProfile(fixture('python', { 'pyproject.toml': '[project]\nname="fixture"\n' }).boundaries[0]), {
+    boundary: '.', flutter_dart: false, node_typescript: false, python: true, go: false, rust: false, java_kotlin: false,
+    firebase: false, supabase: false, rest_openapi: false, getx: false,
   });
   fs.rmSync(root, { recursive: true, force: true });
 });
 
+function pickProfile(profile) {
+  const {
+    boundary, flutter_dart, node_typescript, python, go, rust, java_kotlin,
+    firebase, supabase, rest_openapi, getx,
+  } = profile;
+  return {
+    boundary, flutter_dart, node_typescript, python, go, rust, java_kotlin,
+    firebase, supabase, rest_openapi, getx,
+  };
+}
+
+test('perfis: Go, Rust, Java/Kotlin, Firebase, Supabase e REST/OpenAPI são detectáveis', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'atlas-stack-extra-'));
+  const fixture = (name, files) => {
+    const dir = path.join(root, name); fs.mkdirSync(dir);
+    for (const [file, content] of Object.entries(files)) fs.writeFileSync(path.join(dir, file), content);
+    return detectStackProfiles(dir).boundaries[0];
+  };
+  assert.equal(fixture('go', { 'go.mod': 'module example.com/app\n' }).go, true);
+  assert.equal(fixture('rust', { 'Cargo.toml': '[package]\nname="app"\n' }).rust, true);
+  assert.equal(fixture('java', { 'pom.xml': '<project><dependencies></dependencies></project>\n' }).java_kotlin, true);
+  assert.equal(fixture('firebase', { 'firebase.json': '{"firestore":{}}\n' }).firebase, true);
+  assert.equal(fixture('supabase', { 'package.json': '{"dependencies":{"@supabase/supabase-js":"latest"}}\n' }).supabase, true);
+  assert.equal(fixture('openapi', { 'openapi.yaml': 'openapi: 3.0.0\ninfo:\n  title: API\n  version: 1\n' }).rest_openapi, true);
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
 test('perfis: monorepo restringe stack por boundary e GetX exige evidência', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'atlas-monorepo-'));
   fs.mkdirSync(path.join(root, 'packages/node'), { recursive: true });

package/hosts/opencode/.opencode/atlas/VERSION

@@ -1 +1 @@
-0.9.2
+0.9.4

package/hosts/opencode/.opencode/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.1
+**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/opencode/.opencode/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/opencode/.opencode/atlas/orchestrator/references/host-adapters.md

@@ -11,7 +11,7 @@ Tools nativas do cliente (`Agent()`, `TodoWrite`, `tasks`, `$skill`) vivem no ho
 1. **Runtime:** `atlas_capabilities` (MCP) — detecta host por env e retorna o descritor. Preferir sempre.
 2. **Estático:** esta tabela — fallback de leitura/documentação quando o MCP não está disponível.
 
-Os dois devem permanecer consistentes. O descritor em código vive em `packages/mcp-server/server.js` (`HOST_ADAPTERS`).
+Os dois devem permanecer consistentes. O descritor em código vive em `packages/mcp-server/server.js` (`HOST_ADAPTERS`). ZCode usa o mesmo formato de agentes que Claude (`.md` com frontmatter) por ser Claude Agent SDK compat.
 
 ## Detecção de host
 
@@ -21,6 +21,7 @@ Os dois devem permanecer consistentes. O descritor em código vive em `packages/
 | env `ATLAS_HOST` | o valor da env |
 | env `CLAUDE_PLUGIN_ROOT` presente | `claude` |
 | env `CODEX_HOME` / `CODEX_PLUGIN_ROOT` | `codex` |
+| env `ZCODE_PLUGIN_ROOT` (injetado pelo `.zcode-plugin` do host) | `zcode` |
 | env `ATLAS_HOST=opencode` (injetado por `opencode.json`) | `opencode` |
 | env `ATLAS_HOST=pi` (injetado pela config do `pi-mcp-adapter`) | `pi` |
 | env `ATLAS_HOST=antigravity` (injetado por `mcp_config.json`) | `antigravity` |
@@ -28,15 +29,15 @@ Os dois devem permanecer consistentes. O descritor em código vive em `packages/
 
 ## Matriz de adapters
 
-| Concern | `claude` (Claude Code) | `codex` (Codex App) | `opencode` | `pi` (pi cli) | `antigravity` (Gemini) | `generic` |
-|---------|------------------------|---------------------|------------|---------------|------------------------|-----------|
-| Disparo de subagente | `Agent(subagent_type: "<name>", prompt: "<state_path>")` | `spawn_agent(agent_type: "<name>", items: [{ type: "text", text: "<state_path>" }])` | `@<name>` (ou auto) com `<state_path>` | tool `subagent({ agent: "<name>", task: "<state_path>", context: "fresh" })` (pi-subagents) | `define_subagent` + `invoke_subagent` com `<state_path>` | subagente nativo do host, passando só `<state_path>` |
-| Registro do subagente | `agents/<name>.md` na raiz do plugin | `CODEX_HOME/agents/<name>.toml` via `init codex` (`.codex/agents/` no bundle é fonte gerada; custom agent nativo; `developer_instructions` carrega o `SKILL.md`; `atlas-task-validator` pinado em `model="gpt-5.4"` + `model_reasoning_effort="high"`) | `.opencode/agents/<name>.md` (`mode: subagent`) | `.pi/agents/<name>.md` (pi-subagents; frontmatter `name`+`description`+`tools`; **`SKILL.md` canônico embutido no corpo** porque o pi não tem skill loader no sub-agente — fonte única segue `packages/skills/<name>/SKILL.md`, agente é cópia gerada por `build/gen-host-agent.mjs`) | dinâmico via `define_subagent` da skill do orquestrador | mecanismo nativo equivalente |
-| Topologia do validador frio (G4) | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** |
-| Join síncrono (gate JOIN) | `self_evident` (`Agent()` bloqueante) | `self_evident` (confirmado em produção) | `self_evident` (`@<name>` bloqueante) | `must_report` (depende de `pi-subagents`; hard-fail sem report) | `self_evident` (`invoke_subagent` bloqueante) | `must_report` (indeterminado; hard-fail sem report) |
-| Todo nativo | `TodoWrite` | `tasks` | `todowrite` | nenhum (segue sem mirror) | nenhum (segue sem mirror) | nenhum (segue sem mirror) |
-| Config MCP | `plugin.json` `mcpServers` | `.mcp.json` | `opencode.json` `mcp.<name>` (`type:"local"`, `environment.ATLAS_HOST=opencode`) | `.mcp.json` no root (`pi-mcp-adapter`; `env.ATLAS_HOST=pi`); tools chegam proxiadas/prefixadas `atlas_workflow_<tool>` | `mcp_config.json` (`env.ATLAS_HOST=antigravity`) | host MCP-capaz |
-| Deps externas obrigatórias | — | — | — | **`pi-mcp-adapter` + `pi-subagents`** (DEC-005) | — | — |
+| Concern | `claude` (Claude Code) | `codex` (Codex App) | `opencode` | `pi` (pi cli) | `antigravity` (Gemini) | `zcode` (ZCode) | `generic` |
+|---------|------------------------|---------------------|------------|---------------|------------------------|-----------|-----------|
+| Disparo de subagente | `Agent(subagent_type: "<name>", prompt: "<state_path>")` | `spawn_agent(agent_type: "<name>", items: [{ type: "text", text: "<state_path>" }])` | `@<name>` (ou auto) com `<state_path>` | tool `subagent({ agent: "<name>", task: "<state_path>", context: "fresh" })` (pi-subagents) | `define_subagent` + `invoke_subagent` com `<state_path>` | `Agent(subagent_type: "<name>", prompt: "<state_path>")` | subagente nativo do host, passando só `<state_path>` |
+| Registro do subagente | `agents/<name>.md` na raiz do plugin | `CODEX_HOME/agents/<name>.toml` via `init codex` (`.codex/agents/` no bundle é fonte gerada; custom agent nativo; `developer_instructions` carrega o `SKILL.md`; `atlas-task-validator` pinado em `model="gpt-5.4"` + `model_reasoning_effort="high"`) | `.opencode/agents/<name>.md` (`mode: subagent`) | `.pi/agents/<name>.md` (pi-subagents; frontmatter `name`+`description`+`tools`; **`SKILL.md` canônico embutido no corpo** porque o pi não tem skill loader no sub-agente — fonte única segue `packages/skills/<name>/SKILL.md`, agente é cópia gerada por `build/gen-host-agent.mjs`) | dinâmico via `define_subagent` da skill do orquestrador | `agents/<name>.md` na raiz do plugin (.zcode-plugin) — mesmo formato claude (Claude Agent SDK) | mecanismo nativo equivalente |
+| Topologia do validador frio (G4) | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** | **`sibling`** |
+| Join síncrono (gate JOIN) | `self_evident` (`Agent()` bloqueante) | `self_evident` (confirmado em produção) | `self_evident` (`@<name>` bloqueante) | `must_report` (depende de `pi-subagents`; hard-fail sem report) | `self_evident` (`invoke_subagent` bloqueante) | `self_evident` (`Agent()` bloqueante; Claude Agent SDK) | `must_report` (indeterminado; hard-fail sem report) |
+| Todo nativo | `TodoWrite` | `tasks` | `todowrite` | nenhum (segue sem mirror) | nenhum (segue sem mirror) | `TodoWrite` | nenhum (segue sem mirror) |
+| Config MCP | `plugin.json` `mcpServers` | `.mcp.json` | `opencode.json` `mcp.<name>` (`type:"local"`, `environment.ATLAS_HOST=opencode`) | `.mcp.json` no root (`pi-mcp-adapter`; `env.ATLAS_HOST=pi`; tools chegam proxiadas/prefixadas `atlas_workflow_<tool>`) | `mcp_config.json` (`env.ATLAS_HOST=antigravity`) | `.zcode-plugin/plugin.json` `mcpServers` (stdio; `ZCODE_PLUGIN_ROOT` injetado pelo host) | host MCP-capaz |
+| Deps externas obrigatórias | — | — | — | **`pi-mcp-adapter` + `pi-subagents`** (DEC-005) | — | — | — |
 | Estado de run | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) | `atlas_run_state` (MCP) |
 | Escrita de plano | `.atlas/plans/` | `.atlas/plans/` | `.atlas/plans/` | `.atlas/plans/` | `.atlas/plans/` | `.atlas/plans/` |
 | Leitura de plano (ordem) | `.atlas/plans/` → `.cursor/plans/` → `.codex/plans/` | idem | idem | idem | idem | idem |
@@ -92,7 +93,7 @@ Campos retornados (DEC-007):
 1. Adicionar entrada em `HOST_ADAPTERS` (`packages/mcp-server/server.js`).
 2. Adicionar regra de detecção em `detectHost` se houver env próprio.
 3. Adicionar linha na matriz de adapters.
-4. Registrar o subagente no formato nativo do host (ex.: `agents/<name>.md` ou equivalente).
+4. Registrar o subagente no formato nativo do host (ex.: `agents/<name>.md` ou equivalente). ZCode reusa o formato Claude (`agents/<name>.md`) — mesmo formato, sem geração extra.
 
 Sem tocar nas skills — elas já consomem o descritor.
 
@@ -102,4 +103,4 @@ Sem tocar nas skills — elas já consomem o descritor.
 
 ## Status multi-host
 
-Todos os hosts-alvo do survey S01 estão implementados na matriz acima: `claude`, `codex`, `cursor` (carona no manifest claude), `opencode` (S06), `pi` (S07) e `generic`. Nenhum exige HTTP/SSE → stdio único (DEC-006/S05). Survey completo + fontes: `PRD_S01_host_survey.md`.
+Todos os hosts-alvo do survey S01 estão implementados na matriz acima: `claude`, `codex`, `cursor` (carona no manifest claude), `opencode` (S06), `pi` (S07), `zcode` (Claude Agent SDK compat) e `generic`. Nenhum exige HTTP/SSE → stdio único (DEC-006/S05). Survey completo + fontes: `PRD_S01_host_survey.md`.

package/hosts/opencode/.opencode/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`