atlas-workflow 0.9.1 → 0.9.3

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.3 — 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.3`) · **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/pauloborini/atlas-workflow-orchestrator/<version>/` e registra o plugin no `marketplace.json` do ZCode. 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`.
 

package/VERSION

@@ -1 +1 @@
-0.9.1
+0.9.3

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/classify-findings.test.mjs

@@ -0,0 +1,20 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { classifyFindings } from '../../packages/skills/atlas-slice-review/scripts/classify_findings.mjs';
+
+const valid = () => ({
+  severity: 'P1', task_id: 'T01', title: 'Finding', file: 'a.js', line: 1,
+  failure_mode: 'falha', evidence: 'evidência', recommendation: 'corrigir', fix_validation: 'testar',
+});
+
+test('classificador aceita finding completo e array vazio', () => {
+  assert.equal(classifyFindings([valid()])[0].recommendation, 'corrigir');
+  assert.deepEqual(classifyFindings([]), []);
+});
+
+test('classificador rejeita severidade, linha e campos inválidos', () => {
+  assert.throws(() => classifyFindings([{ ...valid(), severity: 'high' }]), /invalid severity/);
+  assert.throws(() => classifyFindings([{ ...valid(), line: 0 }]), /invalid line/);
+  const missing = valid(); delete missing.recommendation;
+  assert.throws(() => classifyFindings([missing]), /recommendation/);
+});

package/build/tests/etapa3.test.mjs

@@ -0,0 +1,161 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+import {
+  closedDecisionIds,
+  detectStackProfiles,
+  pendingInterviewQuestions,
+  persistInterviewRound,
+  resolveSprintAuthority,
+  validateBacklogUpdate,
+} from '../../packages/skills/_shared/scripts/document_quality.mjs';
+
+const ROOT = path.resolve(import.meta.dirname, '../..');
+const CLASSIFIER = path.join(ROOT, 'packages/skills/atlas-slice-review/scripts/classify_findings.mjs');
+
+const finding = {
+  severity: 'P1', task_id: 'T01', title: 'Falha', file: 'src/a.js', line: 3,
+  failure_mode: 'Falha alcançável.', evidence: 'Guard ausente.',
+  recommendation: 'Restabelecer guard.', fix_validation: 'Teste negativo.',
+};
+
+test('review: gate canônico executa diretamente com Node, sem Python no PATH', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'atlas-review-'));
+  const input = path.join(dir, 'findings.json');
+  fs.writeFileSync(input, JSON.stringify([finding]));
+  const output = execFileSync(process.execPath, [CLASSIFIER, input], { env: { ...process.env, PATH: dir }, encoding: 'utf8' });
+  assert.equal(JSON.parse(output)[0].title, 'Falha');
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test('perfis: Flutter, Node e Python ativam só regras aplicáveis', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'atlas-stack-'));
+  const fixture = (name, files, commands = []) => {
+    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, 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(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(fixture('python', { 'pyproject.toml': '[project]\nname="fixture"\n' }).boundaries[0], {
+    boundary: '.', universal: true, flutter_dart: false, node_typescript: false, python: true, getx: false,
+  });
+  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 });
+  fs.mkdirSync(path.join(root, 'apps/flutter'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'apps/getx'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'packages/node/package.json'), '{}');
+  fs.writeFileSync(path.join(root, 'apps/flutter/pubspec.yaml'), 'name: plain\ndependencies:\n  flutter:\n    sdk: flutter\n');
+  fs.writeFileSync(path.join(root, 'apps/getx/pubspec.yaml'), 'name: getx\ndependencies:\n  flutter:\n    sdk: flutter\n  get: ^4.7.0\n');
+  const profiles = detectStackProfiles(root, [], ['packages/node', 'apps/flutter', 'apps/getx']);
+  assert.deepEqual(profiles.boundaries.map(({ boundary, node_typescript, flutter_dart, getx }) => (
+    { boundary, node_typescript, flutter_dart, getx }
+  )), [
+    { boundary: 'packages/node', node_typescript: true, flutter_dart: false, getx: false },
+    { boundary: 'apps/flutter', node_typescript: false, flutter_dart: true, getx: false },
+    { boundary: 'apps/getx', node_typescript: false, flutter_dart: true, getx: true },
+  ]);
+  assert.throws(() => detectStackProfiles(root, [], ['../outside']), /BOUNDARY_OUTSIDE_PROJECT/);
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+function backlog(rows, decisions = '| D1 | Contrato fechado | S02 | Produto | decidido |', changelog = '- 2026-06-22 — baseline.') {
+  return `# Backlog\n\n### Decisões bloqueantes\n\n| ID | Decisão | Bloqueia | Dono | Status |\n|---|---|---|---|---|\n${decisions}\n\n## 7. Registro de sprints\n\n| ID | Sprint | Fase-fonte | Objetivo (1 linha) | MoSCoW | Ganho | Esforço | Prioridade | PRD | Depende de | Estado | Gate |\n|---|---|---|---|---|---|---|---|---|---|---|---|\n${rows.join('\n')}\n${changelog ? `\n## Registro de alterações\n\n${changelog}` : ''}\n`;
+}
+
+const done = '| S01 | Base | F0 | Fechar base | Must | Alto | Baixo | P0 | `PRD_S01_base.md` | — | done | ✅ |';
+const todo = '| S02 | Próxima | F1 | Entregar próxima | Must | Alto | Médio | P0 | `PRD_S02_proxima.md` | S01 | backlog | — |';
+
+test('backlog update: preserva sprint done, decisão fechada e itens não relacionados', () => {
+  const before = backlog([done, todo]);
+  const after = backlog(
+    [done, todo, '| S03 | Extra | F2 | Entregar extra | Should | Médio | Baixo | P1 | `PRD_S03_extra.md` | S01 | backlog | — |'],
+    undefined,
+    '- 2026-06-22 — baseline.\n- 2026-06-22 — S03 adicionada.',
+  );
+  assert.deepEqual(validateBacklogUpdate(before, after), { valid: true, errors: [] });
+  const destructive = backlog([done.replace('Base', 'Base reescrita'), todo]);
+  assert.ok(validateBacklogUpdate(before, destructive).errors.includes('DONE_SPRINT_CHANGED:S01'));
+});
+
+test('backlog update: bloqueia dependência cíclica', () => {
+  const before = backlog([done, todo]);
+  const cyclic = backlog([
+    '| S01 | Base | F0 | Fechar base | Must | Alto | Baixo | P0 | `PRD_S01_base.md` | S02 | backlog | — |',
+    '| S02 | Próxima | F1 | Entregar próxima | Must | Alto | Médio | P0 | `PRD_S02_proxima.md` | S01 | backlog | — |',
+  ]);
+  assert.ok(validateBacklogUpdate(before, cyclic).errors.some((error) => error.startsWith('DEPENDENCY_CYCLE:')));
+});
+
+test('backlog update: bloqueia dependência inexistente, mudança não autorizada e histórico reescrito', () => {
+  const before = backlog([done, todo]);
+  const missing = backlog(
+    [done, todo.replace('S01 | backlog', 'S99 | backlog')], undefined,
+    '- 2026-06-22 — baseline.\n- 2026-06-22 — dependência alterada.',
+  );
+  assert.ok(validateBacklogUpdate(before, missing, { authorizedIds: ['S02'] }).errors.includes('DEPENDENCY_NOT_FOUND:S02:S99'));
+  const unauthorized = backlog(
+    [done, todo.replace('Próxima', 'Reescrita')], undefined,
+    '- 2026-06-22 — baseline.\n- 2026-06-22 — S02 alterada.',
+  );
+  assert.ok(validateBacklogUpdate(before, unauthorized).errors.includes('UNAUTHORIZED_SPRINT_CHANGED:S02'));
+  const rewritten = backlog(
+    [done, todo, '| S03 | Extra | F2 | Entregar extra | Should | Médio | Baixo | P1 | p | S01 | backlog | — |'],
+    undefined,
+    '- 2026-06-22 — histórico substituído.',
+  );
+  assert.ok(validateBacklogUpdate(before, rewritten).errors.includes('CHANGELOG_REWRITTEN'));
+});
+
+test('Sprint PRD: múltiplos backlogs conflitantes bloqueiam autoridade', () => {
+  assert.throws(() => resolveSprintAuthority({
+    sprintId: 'S03', candidates: [
+      { path: '/repo/a/BACKLOG_MESTRE.md', sprints: ['S03'] },
+      { path: '/repo/b/BACKLOG_MESTRE.md', sprints: ['S03'] },
+    ],
+  }), /AMBIGUOUS_BACKLOG_AUTHORITY/);
+  assert.equal(resolveSprintAuthority({
+    sprintId: 'S03', explicitPath: '/repo/b/BACKLOG_MESTRE.md', candidates: [
+      { path: '/repo/a/BACKLOG_MESTRE.md', sprints: ['S03'] },
+      { path: '/repo/b/BACKLOG_MESTRE.md', sprints: ['S03'] },
+    ],
+  }).path, path.resolve('/repo/b/BACKLOG_MESTRE.md'));
+});
+
+test('interview: persiste resposta e não repete decisão fechada', () => {
+  const prd = '## 3. Decisões de produto (fechadas)\n\n| ID | Decisão |\n|---|---|\n| D1 | Escolha anterior |\n\n## 4. Fluxos\n';
+  const questions = [{ decision_id: 'D1' }, { decision_id: 'D2' }];
+  assert.deepEqual(pendingInterviewQuestions(prd, questions), [{ decision_id: 'D2' }]);
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'atlas-interview-'));
+  const prdPath = path.join(dir, 'PRD.md');
+  fs.writeFileSync(prdPath, prd);
+  const updated = persistInterviewRound(prdPath, [{ decision_id: 'D2', value: 'Nova escolha' }], '2026-06-22');
+  assert.equal(fs.readFileSync(prdPath, 'utf8'), updated);
+  assert.deepEqual([...closedDecisionIds(updated)].sort(), ['D1', 'D2']);
+  assert.deepEqual(pendingInterviewQuestions(updated, questions), []);
+  assert.match(updated, /entrevista: D2 persistida/);
+  const moduleUrl = new URL('../../packages/skills/_shared/scripts/document_quality.mjs', import.meta.url).href;
+  const freshProcess = execFileSync(process.execPath, ['--input-type=module', '-e', `
+    import fs from 'node:fs';
+    import { pendingInterviewQuestions } from ${JSON.stringify(moduleUrl)};
+    process.stdout.write(JSON.stringify(pendingInterviewQuestions(fs.readFileSync(process.argv[1], 'utf8'), [{ decision_id: 'D2' }])));
+  `, prdPath], { encoding: 'utf8' });
+  assert.deepEqual(JSON.parse(freshProcess), []);
+  const invalidPath = path.join(dir, 'INVALID.md');
+  fs.writeFileSync(invalidPath, '# PRD sem tabela de decisões\n');
+  assert.throws(() => persistInterviewRound(invalidPath, [{ decision_id: 'D3', value: 'x' }]), /DECISION_NOT_MATERIALIZED/);
+  assert.equal(fs.readFileSync(invalidPath, 'utf8'), '# PRD sem tabela de decisões\n');
+  assert.throws(() => persistInterviewRound(path.join(dir, 'missing', 'PRD.md'), [{ decision_id: 'D3', value: 'x' }]), /INTERVIEW_PERSISTENCE_FAILED/);
+  fs.rmSync(dir, { recursive: true, force: true });
+});

package/build/tests/test_classify_findings.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Testes do gate determinístico de findings da atlas-slice-review."""
+
+from __future__ import annotations
+
+import json
+import pathlib
+import subprocess
+import sys
+import tempfile
+import unittest
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "packages/skills/atlas-slice-review/scripts/classify_findings.py"
+
+
+def valid_finding() -> dict[str, object]:
+    return {
+        "severity": "P1",
+        "task_id": "T01",
+        "title": "Finding confirmado",
+        "file": "packages/example.py",
+        "line": 12,
+        "failure_mode": "Entrada inválida alcança estado inconsistente.",
+        "evidence": "Guard ausente na linha indicada.",
+        "recommendation": "Restabelecer o guard no proprietário do invariante.",
+        "fix_validation": "Teste negativo deve manter o estado anterior.",
+    }
+
+
+def run_gate(payload: object) -> subprocess.CompletedProcess[str]:
+    with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", suffix=".json") as handle:
+        json.dump(payload, handle)
+        handle.flush()
+        return subprocess.run(
+            [sys.executable, str(SCRIPT), handle.name],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+
+
+class ClassifyFindingsTest(unittest.TestCase):
+    def test_accepts_complete_finding(self) -> None:
+        result = run_gate([valid_finding()])
+        self.assertEqual(result.returncode, 0, result.stderr)
+        normalized = json.loads(result.stdout)
+        self.assertEqual(normalized[0]["recommendation"], valid_finding()["recommendation"])
+
+    def test_accepts_empty_findings(self) -> None:
+        result = run_gate([])
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(json.loads(result.stdout), [])
+
+    def test_rejects_missing_recommendation(self) -> None:
+        finding = valid_finding()
+        del finding["recommendation"]
+        result = run_gate([finding])
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("recommendation", result.stderr)
+
+    def test_rejects_invalid_severity(self) -> None:
+        finding = valid_finding()
+        finding["severity"] = "high"
+        result = run_gate([finding])
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("invalid severity", result.stderr)
+
+    def test_rejects_invalid_line(self) -> None:
+        finding = valid_finding()
+        finding["line"] = 0
+        result = run_gate([finding])
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("invalid line", result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -32,4 +32,8 @@ O orquestrador passa obrigatoriamente `state_path`, findings estruturados, `vali
 - 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/opencode/.opencode/agents/atlas-task-validator.md

@@ -27,9 +27,14 @@ Leia o JSON em `.atlas/state/<run_id>/<slice>.json` usando o schema em `packages
 2. **Plan path** — `plan_path`, depois leia Section 2 (Invariantes de execução), Section 6 (Contratos técnicos) e Section 8 (Validação e checklist).
 3. **Executed task ids** — `tasks`.
 4. **Boundary refs** — `boundary_refs`.
+5. **Deterministic boundary** — `base_sha`, `head_sha`, `contract_kind` e arrays de evidence/probes.
+6. **Working-tree delta** — confronte `worktree_baseline`, `worktree_final` e árvore atual; dirty preexistente intacto fica fora, mutação posterior entra.
+7. **Repair correlation** — no attempt 2, correlacione findings por ID com `repair_evidence` no mesmo state path.
 
 Não aceite contrato inline, diff colado ou listas de tasks coladas como boundary de validação. Se `state_path` estiver ausente, ilegível, ou faltar qualquer campo obrigatório, retorne JSON com `verdict: "fail"` e um finding P1 `Input insuficiente: <missing item>`.
 
+Compatibilidade: state legado mínimo sem `contract_kind` só é aceito para `atlas-plan-execute`. `atlas-direct-execute` exige extensão completa e `obligations` não vazio. Compare `base_sha...head_sha`, `HEAD` atual e arquivos evidenciados no working tree com `files_changed`; nunca infira base pelo nome da branch. Divergência gera boundary violation + P1.
+
 ## State persistence
 
 Use `atlas_run_state` como fonte primária de metadados da run e estado de gate. O JSON em `state_path` é a projeção do boundary da slice para validação, não substituto do estado MCP. Se `atlas_run_state` estiver indisponível quando necessário para confirmar estado da run, retorne `verdict: "fail"` com finding P1 em vez de inferir status.
@@ -88,7 +93,17 @@ Retorne JSON estrito como output final. Não envolva em Markdown e não anteceda
   "challenge_response": "string (sha256 hex do challenge.file; null se sem challenge)",
   "verdict": "pass | fail | pass_with_observations",
   "findings": [
-    { "severity": "P0|P1|P2|P3", "file": "string", "line": 0, "msg": "string" }
+    {
+      "id": "F-001",
+      "severity": "P0|P1|P2|P3",
+      "file": "string",
+      "line": 1,
+      "failure_mode": "string",
+      "evidence": "string",
+      "recommendation": "string",
+      "fix_validation": "string",
+      "msg": "string (deprecated; derivado por uma release)"
+    }
   ],
   "observations": [
     { "file": "string", "line": 0, "msg": "string" }
@@ -101,6 +116,8 @@ Retorne JSON estrito como output final. Não envolva em Markdown e não anteceda
 
 `dispatch_token` deve ser exatamente `validator_recovery.expected_dispatch_token`. `findings`, `observations` e `boundary_violations` são sempre arrays. Use arrays vazios quando não houver itens.
 
+IDs são únicos, obrigatórios no formato `F-NNN` e estáveis nos dois ciclos; severity é estritamente `P0|P1|P2|P3`. No segundo, devolva `repaired_finding_ids` e confirme que cada ID alvo possui `repair_evidence` com arquivos, checks e `status: resolved`. O MCP rejeita shape incompleto e `pass`/`pass_with_observations` com P0/P1.
+
 ## Severity Model
 
 Escala alinhada com `atlas-slice-review` (`P0/P1/P2/P3`).

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

@@ -1 +1 @@
-0.9.1
+0.9.3

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

@@ -117,7 +117,7 @@ Status:
    ↓
 2. Validate PRD + Interview (condicional)
    ↓
-3. Execute
+3. Execute (`atlas-direct-execute`, mantendo `phase: plan_execute`)
    ↓
 4. Review (se --review)
    ↓
@@ -127,9 +127,11 @@ Status:
 ### Interview-Only Mode
 
 ```
-1. Entrevista direta (sem PRD anterior)
+1. Cria draft mínimo pelo `PRD_TEMPLATE.md` quando a entrada é brainstorm
    ↓
-2. Output (PRD esboço + decisões)
+2. Entrevista `atlas-prd-interview` com `prd_path` válido
+   ↓
+3. Output (PRD esboço + decisões)
 ```
 
 ## Sequências canônicas
@@ -140,7 +142,7 @@ Atlas é família única. Cliente (Claude Code, Cursor, Codex App) é apenas o h
 |------|-----------|
 | `full` | `atlas-sprint-prd-generator` → `atlas-prd-interview` quando necessário → `atlas-plan-handoff` → `atlas-plan-execute` → `atlas-task-validator` → `atlas-findings-repair` (no `fail`) → `atlas-slice-review` somente com `--review` |
 | `direct` | PRD/spec existente → `atlas-direct-execute` → `atlas-task-validator` → `atlas-findings-repair` (no `fail`) → `atlas-slice-review` somente com `--review` |
-| `interview-only` | `atlas-prd-interview` |
+| `interview-only` | draft PRD mínimo (se brainstorm) → `atlas-prd-interview` |
 
 ## Validação automática
 
@@ -220,7 +222,7 @@ Veja este README, `packages/mcp-server/README.md` e os SKILL.md `atlas-*` para o
 
 ---
 
-**Plugin version:** 0.9.1
+**Plugin version:** 0.9.3
 **Author:** Paulo Borini
 **Last updated:** 2026-06-16
 

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

@@ -34,4 +34,4 @@ Exemplos:
 
 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".
 
-**Gates duros (v0.3):** o pipeline é orientado a artefato e MCP. Antes de iniciar, rode a **Fase 0 (Pré-flight)** com `atlas_ping` e `atlas_preflight`; use ids `atlas-*`; garanta que cada sub-agent carregue o `SKILL.md` real antes de agir. Se MCP não responder, resultado exigido estiver ausente ou status for bloqueante, **aborte; nunca use fallback narrativo**. Respeite os Gates G1–G11 + TC da SKILL: `atlas_verify_artifact` antes de avançar (G1); em `full`, nenhum código antes de `PLAN_*.md` validado (G2); skills invocadas de verdade (G3); validador frio como sub-agent separado (G4); `atlas_scan_prd` determinístico e logado (G5); status verificado contra disco e MCP (G6); plano/execução/review como sub-agents reais com `atlas_lock_dispatch` (G7/G8); orquestrador de mãos atadas e dispatch blocking (G9); família única atlas-* via `atlas_preflight` (G10); em `full`, `atlas_assert_after_plan` exige `plan_execute` após plano (G11); PRD/PLAN exigem `atlas_verify_template_conformance` passed com `pending_count: 0` (TC).
+**Gates duros (v0.3):** o pipeline é orientado a artefato e MCP. Antes de iniciar, rode a **Fase 0 (Pré-flight)** com `atlas_ping` e `atlas_preflight`; use ids `atlas-*`; garanta que cada sub-agent carregue o `SKILL.md` real antes de agir. Se MCP não responder, resultado exigido estiver ausente ou status for bloqueante, **aborte; nunca use fallback narrativo**. Respeite os Gates G1–G11 + TC da SKILL: `atlas_verify_artifact` antes de avançar (G1); em `full`, nenhum código antes de `PLAN_*.md` validado (G2); skills invocadas de verdade (G3); validador frio como sub-agent separado (G4); `atlas_scan_prd` determinístico e logado (G5); status verificado contra disco e MCP (G6); execução/review como sub-agents reais com `atlas_lock_dispatch`, enquanto PRD/entrevista/plano são autoria documental no pai (G7/G8); orquestrador de mãos atadas e dispatch blocking (G9); família única atlas-* via `atlas_preflight` (G10); em `full`, `atlas_assert_after_plan` exige `atlas-plan-execute` após plano (G11); `direct` usa `atlas-direct-execute`; ambos mantêm `phase: plan_execute`; PRD/PLAN exigem `atlas_verify_template_conformance` passed com `pending_count: 0` (TC). Em `interview-only brainstorm`, crie draft mínimo pelo template antes de invocar `atlas-prd-interview` com `prd_path` válido.