atlas-workflow 0.9.1 → 0.9.2

package/VERSION

@@ -1 +1 @@
-0.9.1
+0.9.2

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.2

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
 

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.

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

@@ -21,7 +21,7 @@ Orquestra pipelines de desenvolvimento de features no projeto Atlas, automatizan
 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`).
 
 - **`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) → executor → review (opcional). **Não produz plano de handoff** — a diferença real para `full` é exatamente essa.
+- **`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).
 
@@ -51,7 +51,7 @@ Três modos **canônicos de execução** — `full`, `direct`, `execute` (PRD §
 → Gera PRD de indicação, força entrevista, plano, executor
 
 /workflow interview-only brainstorm "que tal dark mode?"
-→ Entrevista direto, sem PRD prévio
+→ Cria draft mínimo pelo template canônico, valida o path e entrevista esse PRD; sem execução
 
 /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.
@@ -102,7 +102,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`/`direct` executam `plan_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.
 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.
 
 ---
@@ -120,7 +120,7 @@ O pipeline é **fire-and-continue**: uma vez iniciado, o orquestrador avança fa
 
 **Após entrevista**: reexecuta os gates afetados (`atlas_verify_artifact`/`atlas_scan_prd`/TC) e **retoma o pipeline (plano→execução) automaticamente**, sem nova confirmação.
 
-A única interação legítima com o usuário é **dentro de uma fase** — o `AskUserQuestion` da entrevista para resolver ambiguidade de produto. Resolver ambiguidade ≠ pedir permissão pra avançar. Terminada a fase, o pipeline segue sozinho até o próximo gate duro ou o output final.
+A única interação legítima com o usuário é **dentro de uma fase** — o mecanismo estruturado `question_prompt` devolvido por `atlas_capabilities`, usado pela entrevista para resolver ambiguidade de produto. Resolver ambiguidade ≠ pedir permissão pra avançar. Terminada a fase, respostas são persistidas no PRD, gates são reexecutados e o pipeline segue sozinho.
 
 ## Papel do orquestrador (fronteira de determinismo pela mutação de código)
 
@@ -129,7 +129,7 @@ O orquestrador **coordena a execução**, não implementa código — maestro qu
 - **ANTES do plano validado — autoria documental livre no fio principal.** Pode autorar PRD, entrevistar e escrever `PLAN_*.md` direto; fases documentais não exigem sub-agent (documento não muta o produto). **Ao finalizar um PRD inline, estampar `| Status | Aprovado para implementação |`** — é o `required_status` do gate TC; sem isso o PRD sai `Draft` e trava o TC em rodadas de correção.
 - **DEPOIS do plano validado (`atlas_verify_artifact` + TC `passed`) — mãos atadas fortes.** Não edita mais PRD/plano/código nem roda comando mutante; só coordena (despachar sub-agent, ler artefato pra verificar gate, ecoar banner, montar output).
 
-Execução de código é **sempre** sub-agent `plan_execute` (blocking, um por vez) + validador frio `task_validator` (Gate G9/G7 — detalhe na tabela de gates). Dispatch blocking: despacha → espera retorno → verifica gate → próxima fase. Nunca dois sub-agents simultâneos.
+Execução de código é **sempre** sub-agent executor do modo (`atlas-plan-execute` em `full`/`execute`; `atlas-direct-execute` em `direct`), mantendo `phase: plan_execute`, + validador frio `task_validator` (Gate G9/G7). Dispatch blocking: despacha → espera retorno → verifica gate → próxima fase. Nunca dois sub-agents simultâneos.
 
 ### Verbo de dispatch é host-agnóstico (não assuma "Agent tool")
 
@@ -180,9 +180,9 @@ Regras inegociáveis. Violação = parar, não contornar.
 
 ## Fluxo de execução
 
-### [EXEC] — passo comum de execução + validação (idêntico em `full`/`direct`/`execute`)
+### [EXEC] — passo comum de execução + validação
 
-`atlas_lock_dispatch(action=start, phase=plan_execute)`; despachar `plan_execute` como sub-agent blocking (lê `PLAN_*.md` em `full`/`execute`, PRD 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`. 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
 
@@ -225,8 +225,9 @@ Entrada: um **`PLAN_*.md` pronto**. Artefatos esperados: (plano já existe) →
 
 ### Interview-only mode
 
-1. Entrevista direta (sem PRD anterior) — invoca o id resolvido para `prd_interview`.
-2. Gera PRD esboço (opcional).
+1. Se a entrada já for PRD válido, usar seu path. Se for `brainstorm`, criar primeiro um draft mínimo em disco com `packages/templates/PRD_TEMPLATE.md`, preservando as 6 seções canônicas e registrando o brainstorm em contexto/objetivo.
+2. Verificar o draft com `atlas_verify_artifact` e `atlas_verify_template_conformance(artifact_type=prd)`; path ausente/inválido bloqueia.
+3. Invocar `prd_interview` no fio principal com `prd_path` válido; persistir respostas no mesmo artefato e reverificar.
 
 > `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.
 
@@ -245,9 +246,10 @@ O scan é **determinístico** e roda **dentro do MCP** (`atlas_scan_prd`): a lis
 Detalhe do caminho que a "Princípio de continuação automática" exige para decisão pendente de **qualquer fonte** (scan/entrevista/validação de plano/`PERGUNTAS_EM_ABERTO.md`/`DISCUSSAO_*.md`/backlog — a fonte não muda o tratamento):
 
 1. **Garantir o PRD primeiro.** Em `full`/`direct`, se o PRD não existe, **gerar o PRD draft** com as decisões marcadas. A entrevista é **PRD-scoped**: roda **sobre** o PRD, nunca antes. Detectar decisão não antecipa nem pula a geração do PRD.
-2. **Disparar `atlas-prd-interview`** sobre o PRD — resolve via `AskUserQuestion` (interação dentro da fase, não pedido de permissão).
-3. **Propagar** ao PRD/plano/DEC/registro de origem.
-4. **Reexecutar** os gates afetados (`atlas_verify_artifact`/`atlas_scan_prd`/TC) e **continuar** automaticamente.
+2. **Disparar `atlas-prd-interview`** sobre o PRD — resolve via `atlas_capabilities.question_prompt`, sem hardcode de host.
+3. **Persistir após cada rodada** no mesmo PRD, reindexar §3–§6 e não repetir D* fechada.
+4. **Propagar** ao PRD/plano/DEC/registro de origem.
+5. **Reexecutar** os gates afetados (`atlas_verify_artifact`/`atlas_scan_prd`/TC) e **continuar** automaticamente.
 
 Marcar TBD e adiar só se o usuário pedir **explicitamente** — nunca por iniciativa do orquestrador.
 
@@ -326,13 +328,16 @@ 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.
+
 | Skill | Entrada | Saída (artefato) |
 |-------|---------|------------------|
-| `atlas-backlog-generator` | ideia/prompt/conversa/briefing | `BACKLOG_MESTRE_*.md` |
+| `atlas-backlog-generator` (**explicit-only**) | pedido explícito de backlog | `BACKLOG_MESTRE_*.md` |
 | `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-plan-execute` | plan_path (full / **execute**) ou prd_path (direct) | diff de código, evidência |
+| `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 |
 
 **Sub-agent frio (Gate G4):** `atlas-task-validator` é verificado no pré-flight pelo orquestrador e sempre roda isolado como **sub-agent irmão (sibling)**, em todos os hosts: despachado pelo orquestrador a partir do `state_path` retornado pelo executor. A topologia é sempre sibling — o executor nunca despacha o validador.
@@ -356,11 +361,11 @@ Se o MCP não responder ou reportar drift, o pacote está inválido: abortar no
 ```
 orquestrador
  ├─ MCP ping + preflight                         → atlas_ping + atlas_preflight (G10)
- ├─ PRD        → sub-agent                       → atlas_verify_artifact (G1)
+ ├─ PRD        → autoria documental no pai       → atlas_verify_artifact (G1)
  ├─ scan       → atlas_scan_prd (G5) + TC        → entrevista se bloqueado ou --interview
- ├─ PLANO      → lock_dispatch + sub-agent       → atlas_verify_artifact + atlas_verify_template_conformance
+ ├─ PLANO      → autoria documental no pai       → atlas_verify_artifact + atlas_verify_template_conformance
  ├─ G11        → atlas_assert_after_plan         → próxima ação obrigatória = plan_execute
- ├─ EXECUÇÃO   → atlas_lock_dispatch + sub-agent plan_execute
+ ├─ EXECUÇÃO   → atlas_lock_dispatch + sub-agent atlas-plan-execute
  ├─ VALIDAÇÃO  → lock_validator + task-validator irmão
  │                └─ fail → findings-repair (budget 1, mesmo state_path) → validator final
  └─ REVIEW     → atlas_lock_dispatch + sub-agent slice_review (se --review)

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

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