atlas-workflow 0.9.1 → 0.9.2

package/hosts/pi/skills/atlas-slice-review/references/scenario-lenses.md

@@ -34,6 +34,14 @@ Use these lenses to find hidden bugs in the executed slice. Apply only the relev
 - Is retry or re-entry behavior still coherent after this slice?
 - Did generated files, localization keys, imports, routes, RPC signatures, or schemas match the verified repo convention?
 
+## Mecânica da mudança
+
+- Qual invariante cada guard, validação, cleanup, error path ou teste removido/substituído protegia, e onde ele foi restabelecido?
+- Callers e callees alterados ainda concordam sobre pré-condições, shapes de retorno, erros, timing e ordem?
+- A mudança corrige o componente proprietário do invariante ou adiciona um caso especial local frágil?
+- Algum novo problema de reuse, simplificação ou eficiência tem custo comportamental, operacional ou de manutenção concreto?
+- As instruções aplicáveis do repo expõem uma violação exata, atribuível a uma linha e com impacto concreto?
+
 ## Security and safety
 
 - Did the slice weaken permission, ownership, or visibility checks?

package/hosts/pi/skills/atlas-slice-review/scripts/classify_findings.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+
+export const SEVERITY_ORDER = Object.freeze({ P0: 0, P1: 1, P2: 2, P3: 3 });
+export const REQUIRED_TEXT_FIELDS = Object.freeze([
+  'task_id', 'title', 'file', 'failure_mode', 'evidence', 'recommendation', 'fix_validation',
+]);
+
+export function normalizeFinding(finding, index) {
+  if (!finding || typeof finding !== 'object' || Array.isArray(finding)) {
+    throw new Error(`Finding ${index} must be a JSON object`);
+  }
+  if (!(finding.severity in SEVERITY_ORDER)) {
+    throw new Error(`Finding ${index} has invalid severity: ${JSON.stringify(finding.severity)}`);
+  }
+  const missing = REQUIRED_TEXT_FIELDS.filter(
+    (field) => typeof finding[field] !== 'string' || !finding[field].trim(),
+  );
+  if (missing.length) throw new Error(`Finding ${index} missing required fields: ${missing.join(', ')}`);
+  if (!Number.isInteger(finding.line) || finding.line < 1) {
+    throw new Error(`Finding ${index} has invalid line: ${JSON.stringify(finding.line)}`);
+  }
+  return {
+    severity: finding.severity,
+    task_id: finding.task_id,
+    title: finding.title,
+    file: finding.file,
+    line: finding.line,
+    summary: typeof finding.summary === 'string' ? finding.summary : '',
+    failure_mode: finding.failure_mode,
+    evidence: finding.evidence,
+    recommendation: finding.recommendation,
+    fix_validation: finding.fix_validation,
+    diff_attributed: finding.diff_attributed !== false,
+  };
+}
+
+export function classifyFindings(payload) {
+  if (!Array.isArray(payload)) throw new Error('Findings input must be a JSON array');
+  return payload.map(normalizeFinding).sort((a, b) => (
+    SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]
+      || a.task_id.localeCompare(b.task_id)
+      || a.file.localeCompare(b.file)
+      || a.line - b.line
+  ));
+}
+
+export function run(argv = process.argv.slice(2)) {
+  if (argv.length !== 1) throw new Error('Usage: node classify_findings.mjs <findings.json>');
+  const payload = JSON.parse(fs.readFileSync(argv[0], 'utf8'));
+  process.stdout.write(`${JSON.stringify(classifyFindings(payload), null, 2)}\n`);
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? '').href) {
+  try { run(); } catch (error) {
+    process.stderr.write(`${error.message}\n`);
+    process.exitCode = 1;
+  }
+}

package/hosts/pi/skills/atlas-slice-review/scripts/classify_findings.py

@@ -1,56 +1,24 @@
 #!/usr/bin/env python3
-"""Normalize raw findings into a severity-oriented review structure."""
+"""Wrapper legado: delega ao gate Node canônico por uma release."""
 
 from __future__ import annotations
 
-import argparse
-import json
 import pathlib
+import subprocess
 import sys
-from typing import Any
-
-SEVERITY_ORDER = {"P0": 0, "P1": 1, "P2": 2, "P3": 3}
-
-
-def load_findings(path: pathlib.Path) -> list[dict[str, Any]]:
-    payload = json.loads(path.read_text(encoding="utf-8"))
-    if not isinstance(payload, list):
-        raise ValueError("Findings input must be a JSON array")
-    return payload
-
-
-def normalize_finding(finding: dict[str, Any]) -> dict[str, Any]:
-    severity = finding.get("severity", "P2")
-    if severity not in SEVERITY_ORDER:
-        severity = "P2"
-    return {
-        "severity": severity,
-        "task_id": finding.get("task_id", ""),
-        "title": finding.get("title", ""),
-        "file": finding.get("file", ""),
-        "line": finding.get("line"),
-        "summary": finding.get("summary", ""),
-        "evidence": finding.get("evidence", ""),
-        "diff_attributed": bool(finding.get("diff_attributed", True)),
-    }
 
 
 def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("findings_json", help="Path to a JSON array of findings")
-    args = parser.parse_args()
-
+    if len(sys.argv) != 2:
+        sys.stderr.write("Usage: python classify_findings.py <findings.json>\n")
+        return 1
+    script = pathlib.Path(__file__).with_name("classify_findings.mjs")
     try:
-        normalized = [normalize_finding(item) for item in load_findings(pathlib.Path(args.findings_json))]
-    except (FileNotFoundError, ValueError, json.JSONDecodeError) as exc:
-        sys.stderr.write(f"{exc}\n")
+        return subprocess.run(["node", str(script), sys.argv[1]], check=False).returncode
+    except FileNotFoundError:
+        sys.stderr.write("Node.js ausente: requisito runtime do Atlas\n")
         return 1
 
-    normalized.sort(key=lambda item: (SEVERITY_ORDER[item["severity"]], item["task_id"], item["file"], item["line"] or 0))
-    json.dump(normalized, sys.stdout, indent=2)
-    sys.stdout.write("\n")
-    return 0
-
 
 if __name__ == "__main__":
     raise SystemExit(main())

package/hosts/pi/skills/atlas-sprint-prd-generator/SKILL.md

@@ -16,6 +16,7 @@ Todo PRD gerado por esta skill deve declarar explicitamente a cadeia de execuç
 * Sprint ID: `S<NN>` (`S01`, `S02`, etc.).
 * Opcional: app/projeto alvo quando houver mais de uma fonte de backlog/roadmap.
 * Opcional: path de saída.
+* Opcional: path explícito do backlog autoritativo. Quando fornecido, vence qualquer descoberta.
 
 *Se faltar o Sprint ID, peça antes de gerar.*
 
@@ -23,10 +24,11 @@ Todo PRD gerado por esta skill deve declarar explicitamente a cadeia de execuç
 
 ## Workflow Obrigatório
 
-1. **Localizar Insumos:** Descubra a raiz do repo com `git rev-parse --show-toplevel`. Localize o template canônico em `<raiz-do-plugin>/packages/templates/PRD_TEMPLATE.md`. Localize backlog/roadmap no repo ativo (`**/BACKLOG_MESTRE*.md`).
-2. **Extração da Sprint:** Leia a fonte de backlog/roadmap. Localize a sprint, extraindo fase-fonte, objetivo, dependências e filename do PRD.
-3. **Inspecionar Código:** Busque no codebase por classes, tabelas, RPCs, mappers e rotas existentes que influenciam a feature.
-4. **Redação do PRD:** Siga estritamente o layout enxuto e focado do `PRD_TEMPLATE.md` (teto orientativo de ~180-220 linhas), separando dores e regras de negócio de implementações de código.
+1. **Localizar Insumos:** Descubra a raiz do repo com `git rev-parse --show-toplevel`. Localize o template canônico em `<raiz-do-plugin>/packages/templates/PRD_TEMPLATE.md`. Localize backlogs candidatos (`**/BACKLOG_MESTRE*.md`) sem escolher por heurística silenciosa.
+2. **Fechar autoridade:** use `../_shared/scripts/document_quality.mjs#resolveSprintAuthority` com precedência fixa: path explícito → backlog canônico referenciado pelo artefato/input → único candidato contendo o Sprint ID. Zero match bloqueia. Múltiplos matches sem autoridade, mesmo com conteúdo parecido, bloqueiam com paths conflitantes e `next_action` para informar o path.
+3. **Extração da Sprint:** leia somente a fonte autoritativa. Extraia fase-fonte, objetivo, dependências e filename do PRD; registre no PRD o path + anchor exato da linha/seção do backlog.
+4. **Inspecionar Código:** Busque no codebase por contratos reais que influenciam a feature e registre anchors estáveis (`path:símbolo` ou `path:linha`) nas referências; não copie implementação para o PRD.
+5. **Redação/atualização:** siga `PRD_TEMPLATE.md`. Ao atualizar, preserve IDs `D*`, decisões fechadas, anchors e histórico; novos IDs são append-only. Mudança deliberada em D* exige decisão explícita e registro histórico.
 
 ### Resolução Canônica de Templates
 
@@ -57,6 +59,7 @@ Todo PRD criado ou atualizado por esta skill deve incluir, perto do topo e sem s
 
 * **Status final:** `Aprovado para implementação`. Setar **automaticamente** ao finalizar a geração — é o status que o gate TC do orquestrador exige (`required_status=Aprovado para implementação`) para o PRD avançar no pipeline. Não deixar `Draft` (trava o gate e força correção manual). O sinal de determinismo que sustenta o avanço é o `atlas_scan_prd` (varredura de ambiguidade) + entrevista quando houver padrões bloqueantes — não o campo Status, que é marcador documental.
 * **Data:** ISO `YYYY-MM-DD` (hoje).
+* **Autoridade:** `Relacionado`/`Referências` inclui backlog autoritativo + anchor da sprint e anchors de código/contrato usados.
 * **Escopo:** Lista fechada de capacidades funcionais.
 * **UX:** Cobrir caminhos de `loading`, `empty`, `error`, `success` e `permission` sob a perspectiva do usuário.
 * **Critérios de Aceite:** Binários e observáveis, divididos conforme `PRD_TEMPLATE.md` em: **Produto**, **UX**, **Dados** e **Regressão de produto**.

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

@@ -34,9 +34,16 @@ Read the JSON file at `.atlas/state/<run_id>/<slice>.json` using the schema in `
 3. **Executed task ids** — `tasks`.
 4. **Boundary refs** — `boundary_refs`.
 5. **Explicit cold-review note** — you did not observe implementation; read current code only.
+6. **Deterministic boundary** — `base_sha`, `head_sha`, `contract_kind`, and all evidence/probe arrays.
+7. **Working-tree delta** — compare `worktree_baseline`/`worktree_final` and current tree; unchanged preexisting dirt stays outside, later mutations must be evidenced.
+8. **Repair correlation** — on attempt 2, correlate every target finding id with `repair_evidence` in the same state path.
 
 Do not accept inline contract, copied diff, or pasted task lists as the validation boundary. If `state_path` is missing, unreadable, or lacks any required field, return JSON with `verdict: "fail"` and one P1 finding for `Input insuficiente: <missing item>`.
 
+Compatibilidade: state legado mínimo sem `contract_kind` só é aceito quando `executor_skill=atlas-plan-execute`; nesse caso o plano continua autoritativo. State de `atlas-direct-execute` exige extensão completa e `obligations` não vazio.
+
+Antes de validar código, compare `base_sha...head_sha`, `HEAD`, snapshot final atual e delta `worktree_baseline→worktree_final` com `files_changed`/evidências. Não infira base pelo nome da branch. Divergência gera `boundary_violations` e finding P1 estruturado.
+
 ---
 
 ## Resolução Canônica de Templates
@@ -79,23 +86,24 @@ Do not accept inline contract, copied diff, or pasted task lists as the validati
 3. **For each relevant Section 6 Contract:** verify signature, behavior, and returned shape where applicable.
 4. **For each relevant Section 8 checklist item:** mark it pass or fail with evidence.
 5. **Perform cross-task checks** for shared state, missing required args, route order, partial failure handling, and UI/backend permission mismatch.
-6. **Apply universal baseline checks** below. Do not invent new mandatory criteria outside the plan and baseline.
+6. **Aplique baseline + perfis ativos** abaixo. Resolva os perfis por manifests/comandos reais conforme `../_shared/references/stack-profiles.md`; não invente critérios fora do plano, baseline e perfis ativos.
 7. **Do not patch files or propose diffs.** Suggested fix must fit in 1-2 lines of text.
 
 ---
 
-## Universal Baseline
+## Baseline universal + perfis
+
+Fonte compartilhada: `../_shared/references/stack-profiles.md`. Execute `detectStackProfiles(project_root, declared_commands, boundary_paths)` de `../_shared/scripts/document_quality.mjs`; aplique cada entrada de `boundaries` somente aos arquivos daquele package.
+
+Sempre aplique baseline universal: segurança/permissões, boundary/contratos, erros/falhas parciais, concorrência/reentrada, cleanup/estado stale, integridade de dados/input e checks realmente declarados.
+
+Ative regras específicas somente quando o perfil retornar `true`:
 
-Always apply these checks:
-* **Naming cross-layer:** New read methods use `get*` prefix. Mutation uses explicit verbs (`create`, `update`, `delete`, `add`, `remove`). Concepts keep consistent root names across layers.
-* **State lifecycle:** Shared stores or controllers reused across modes or routes must reset previous mode state in `init()` or transition.
-* **Navigation args:** Argument resolvers validate required fields; navigation passes all required ids (no empty placeholder `''`).
-* **Partial failure paths:** Multi-step mutations surface partial persistence clearly if a later step fails.
-* **Backend and UI gate match:** Sensitive mutations require server-side enforcement. UI gating alone is insufficient (Page reads `canManage` from Store).
-* **Route registration:** Literal routes are registered before parameterized routes (`/:id`, `/:id/edit`) under the same prefix.
-* **Localization:** New localization keys must exist in every required locale file; generated l10n is clean.
-* **Analyzer:** `flutter analyze` (or stack equivalent) returns zero issues for touched files in boundary.
-* **Casts and nullability:** Remote payload casts use safe defensive patterns; nulos in collections treated with `?? []`.
+- `flutter_dart`: lifecycle Flutter, rotas/args, null-safety/casts, l10n, analyze/test; GetX somente se dependência/import/regra real confirmar GetX.
+- `node_typescript`: handles/promises, validação runtime, ESM/CJS/exports/tipos e scripts Node reais.
+- `python`: context managers/cleanup, exceções/async, typing/parsing e ferramentas Python declaradas.
+
+Monorepo pode ativar múltiplos perfis, sempre restritos ao boundary correspondente. Fixture Node sem sinal Flutter não recebe regra Flutter/GetX.
 
 ---
 
@@ -110,10 +118,15 @@ Return strict JSON as the final output. Do not wrap it in Markdown and do not pr
   "verdict": "pass | fail | pass_with_observations",
   "findings": [
     {
+      "id": "F-001",
       "severity": "P0|P1|P2|P3",
       "file": "string",
-      "line": 0,
-      "msg": "string"
+      "line": 1,
+      "failure_mode": "string",
+      "evidence": "string",
+      "recommendation": "string",
+      "fix_validation": "string",
+      "msg": "string (deprecated; derivado por uma release)"
     }
   ],
   "observations": [
@@ -134,6 +147,8 @@ Return strict JSON as the final output. Do not wrap it in Markdown and do not pr
 
 `dispatch_token` must equal `validator_recovery.expected_dispatch_token`. `findings`, `observations`, and `boundary_violations` must always be arrays. Use empty arrays when there are no items.
 
+IDs são únicos, obrigatórios no formato `F-NNN` e estáveis nos dois ciclos. Severity é estritamente `P0|P1|P2|P3`. No segundo ciclo, confirme por ID que `repair_evidence` registra arquivos, checks e `status: resolved`; finding não correlacionado permanece P1. O MCP rejeita shape incompleto e `pass`/`pass_with_observations` quando há P0/P1.
+
 **Proof-of-work (`challenge_response`).** If `validator_recovery.challenge` is not `null`, it carries `{ file, algo: "sha256" }` — a boundary file you must have read access to. Compute the sha256 of that file's raw bytes (`shasum -a 256 "<challenge.file>"`) and return the hex (first token) in `challenge_response`. If `challenge` is `null`, return `null`. Never fabricate the hash: the orchestrator recomputes it from disk and blocks the slice (`challenge_failed`) on mismatch. This is a *mechanical* attestation that the verdict touched real boundary bytes — it closes the laziest bypass (claiming `pass` with no read at all); it does **not** by itself prove you read and understood the code (hashing a file does not require loading its content). Reading the boundary remains your obligation. It is not a non-forgeable isolation proof either (the MCP shares one stdio caller). Challenge failures are bounded per attempt: past the cap the slot closes terminally (`challenge_exhausted`), which usually signals path resolution diverging from the consumer root.
 
 ---

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

@@ -1,6 +1,6 @@
 {
   "name": "atlas-workflow",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Instalador multi-host do Atlas Workflow Orchestrator (Claude Code, Cursor, Codex, opencode, pi). Roda via npx-from-GitHub.",
   "type": "module",
   "bin": {

package/plugins/atlas-workflow-orchestrator/.codex/agents/atlas-findings-repair.toml

@@ -1,3 +1,3 @@
 name = "atlas-findings-repair"
 description = "Reparador enxuto da família Atlas. Despachado pelo orquestrador apenas após `atlas-task-validator` retornar `fail` em topologia sibling. Corrige findings P0/P1/P2 dentro do boundary da slice sem carregar `atlas-plan-execute`/`atlas-direct-execute` e sem despachar novo validator."
-developer_instructions = "# Atlas Findings Repair (sub-agent)\n\n<!-- MANUTENÇÃO (cross-host): shim portável. O contrato real vive em\n     packages/skills/atlas-findings-repair/SKILL.md. Codex/opencode/pi geram\n     registros nativos a partir deste arquivo por build/gen-host-agent.mjs. -->\n\nSub-agent de reparo bounded despachado pelo orquestrador `atlas-workflow-orchestrator`.\n\n## Primeira ação obrigatória\n\nCarregue a skill completa `atlas-findings-repair` e siga-a integralmente:\n\n- **Claude Code:** invoque a tool `Skill` com `atlas-findings-repair`.\n- **Outros hosts:** use o mecanismo nativo de skills do host para carregar `atlas-findings-repair`.\n\nProibido “agir como executor” a partir deste resumo. Se não conseguir carregar a skill, aborte com erro explícito; não substitua por `atlas-plan-execute` nem `atlas-direct-execute`.\n\n## Input\n\nO orquestrador passa obrigatoriamente `state_path`, findings estruturados, `validator_attempt`, `repair_run_id` e `repair_budget: 1`. Use `atlas_run_state` como fonte primária do estado da run.\n\n## Limites\n\n- Corrigir apenas findings P0/P1/P2 da slice atual\n- Não despachar validator nem outro subagente\n- Não replanejar\n- Não ampliar escopo\n- Atualizar o `state_path` original em lugar; não trocar o boundary para outro arquivo\n- Ao terminar, devolver `repair_complete` ou `blocked`"
+developer_instructions = "# Atlas Findings Repair (sub-agent)\n\n<!-- MANUTENÇÃO (cross-host): shim portável. O contrato real vive em\n     packages/skills/atlas-findings-repair/SKILL.md. Codex/opencode/pi geram\n     registros nativos a partir deste arquivo por build/gen-host-agent.mjs. -->\n\nSub-agent de reparo bounded despachado pelo orquestrador `atlas-workflow-orchestrator`.\n\n## Primeira ação obrigatória\n\nCarregue a skill completa `atlas-findings-repair` e siga-a integralmente:\n\n- **Claude Code:** invoque a tool `Skill` com `atlas-findings-repair`.\n- **Outros hosts:** use o mecanismo nativo de skills do host para carregar `atlas-findings-repair`.\n\nProibido “agir como executor” a partir deste resumo. Se não conseguir carregar a skill, aborte com erro explícito; não substitua por `atlas-plan-execute` nem `atlas-direct-execute`.\n\n## Input\n\nO orquestrador passa obrigatoriamente `state_path`, findings estruturados, `validator_attempt`, `repair_run_id` e `repair_budget: 1`. Use `atlas_run_state` como fonte primária do estado da run.\n\n## Limites\n\n- Corrigir apenas findings P0/P1/P2 da slice atual\n- Não despachar validator nem outro subagente\n- Não replanejar\n- Não ampliar escopo\n- Atualizar o `state_path` original em lugar; não trocar o boundary para outro arquivo\n- Consumir IDs/recommendations estruturadas; persistir correlação em `repair_evidence`\n- Preservar `worktree_baseline`, recapturar `worktree_final` e incluir exatamente todo arquivo tocado em `files_changed`; recomputar `head_sha` e `diff_stat`\n- Aceitar somente IDs recebidos; cada arquivo tocado deve estar atribuído a um finding recebido, sem IDs/arquivos extras ou duplicados\n- Devolver `repairs[]` com `finding_id`, arquivos, checks e status\n- Ao terminar, devolver `repair_complete` ou `blocked`"

package/plugins/atlas-workflow-orchestrator/.codex/agents/atlas-task-validator.toml

@@ -2,4 +2,4 @@ name = "atlas-task-validator"
 description = "Validador frio de slice executada por atlas-plan-execute ou atlas-direct-execute. Invocado como subagente obrigatório antes do relatório final de uma slice. Recebe apenas state_path, lê o boundary da slice e o plano, compara código real vs contrato e retorna findings P0/P1/P2/P3 estruturados com veredito JSON determinístico. Não corrige código. Não propõe diff."
 model = "gpt-5.4"
 model_reasoning_effort = "high"
-developer_instructions = "# Atlas Task Validator\n\n<!-- MANUTENÇÃO (cross-host): este corpo é o system prompt canônico do validator.\n     Claude usa agents/<name>.md; Codex/opencode/pi geram registros nativos a partir\n     deste arquivo. packages/skills/atlas-task-validator/SKILL.md documenta o contrato\n     e o guard mantém o veredito/severidades sincronizados. -->\n\nSubagente de validação fria. Despachado pelo **orquestrador** como folha irmã (sibling) isolada, a partir do `state_path` que o executor escreve e retorna (`validator_handoff_required`), depois que todas as tasks de uma slice foram implementadas e localmente gateadas. Nunca é invocado pelo executor.\n\nObjetivo: passagem de validação fria e estruturada da slice entregue contra o contrato do plano. Você não observou a implementação — leia apenas o código atual.\n\n---\n\n## Invocation Contract\n\nVocê recebe **um único input base**: `state_path`.\n\nLeia o JSON em `.atlas/state/<run_id>/<slice>.json` usando o schema em `packages/templates/STATE_FILE_SCHEMA.md`. Desse arquivo, carregue:\n\n1. **Slice boundary** — `files_changed` + `diff_stat`.\n2. **Plan path** — `plan_path`, depois leia Section 2 (Invariantes de execução), Section 6 (Contratos técnicos) e Section 8 (Validação e checklist).\n3. **Executed task ids** — `tasks`.\n4. **Boundary refs** — `boundary_refs`.\n\nNã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>`.\n\n## State persistence\n\nUse `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.\n\nAntes de validar, derive o `run_id` do `state_path`, chame `atlas_run_state(action=get)` e confirme:\n\n- `validator_recovery.status == \"running\"`\n- `validator_recovery.expected_state_path == state_path`\n- `validator_recovery.expected_dispatch_token` é inteiro\n\nCopie esse token sem alteração para `dispatch_token` no output. Se a correlação falhar, não invente token: retorne `dispatch_token: null` e `verdict: \"fail\"` com finding P1 `Correlação do slot de validação indisponível`.\n\n### Proof-of-work (challenge do boundary)\n\nSe `validator_recovery.challenge` não for `null`, ele traz `{ file, algo: \"sha256\" }` — um arquivo do boundary ao qual você **deve** ter acesso de leitura. Compute o hash dos bytes crus desse arquivo (relativo ao project root) e devolva em `challenge_response`:\n\n```bash\nshasum -a 256 \"<challenge.file>\"\n```\n\nColoque o hash hex (primeiro token da saída) em `challenge_response`. Se `challenge` for `null`, omita `challenge_response` ou devolva `null`. Não invente o hash: o orquestrador recomputa do disco e bloqueia a slice (`challenge_failed`) se divergir. Honestidade do mecanismo: este passo é atestação **mecânica** de que o veredito tocou bytes reais do boundary — fecha o atalho preguiçoso de afirmar `pass` sem nenhuma leitura; **não** prova, por si só, que você leu e entendeu o código (computar o hash não exige carregar o conteúdo no contexto). A leitura real do boundary continua sendo sua obrigação de validador. Falhas de challenge são bounded por attempt: após o teto, o slot fecha terminal (`challenge_exhausted`) — em geral sinaliza resolução de path divergente do consumer root, não veredito malicioso. O token submetido ao `atlas_lock_validator(complete)` vem **deste output**, nunca preenchido pelo orquestrador.\n\n---\n\n## Operating Rules\n\n1. **Leia código real no boundary da slice.** Não infira conformidade por nome de arquivo ou título de task.\n2. **Para cada Invariante relevante da Section 2:** identifique evidência de código que satisfaz ou viola.\n3. **Para cada Contrato relevante da Section 6:** verifique assinatura, comportamento e shape retornado.\n4. **Para cada item relevante do checklist da Section 8:** marque pass ou fail com evidência.\n5. **Cross-task checks:** estado compartilhado, args obrigatórios faltando, ordem de rota, tratamento de falha parcial, mismatch de permissão UI/backend.\n6. **Baseline universal abaixo.** Não invente critérios obrigatórios fora do plano e do baseline.\n7. **Não corrija arquivos nem proponha diffs.** Sugestão de fix cabe em 1-2 linhas de texto.\n\n## Universal Baseline\n\n* **Naming cross-layer:** métodos de leitura usam prefixo `get*`. Mutação usa verbos explícitos (`create`, `update`, `delete`, `add`, `remove`). Conceitos mantêm raiz consistente entre camadas.\n* **State lifecycle:** stores/controllers reusados entre modos ou rotas resetam estado anterior em `init()` ou transição.\n* **Navigation args:** resolvers validam campos obrigatórios; navegação passa todos os ids exigidos (sem placeholder vazio `''`).\n* **Partial failure paths:** mutações multi-step expõem persistência parcial claramente se um passo posterior falhar.\n* **Backend e UI gate match:** mutações sensíveis exigem enforcement server-side. Gate só de UI é insuficiente.\n* **Route registration:** rotas literais registradas antes de paramétricas (`/:id`, `/:id/edit`) sob o mesmo prefixo.\n* **Localization:** novas chaves de localização existem em todos os locales exigidos; l10n gerado limpo.\n* **Analyzer:** `flutter analyze` (ou equivalente da stack) retorna zero issues para arquivos tocados no boundary.\n* **Casts e nullability:** casts de payload remoto usam padrões defensivos; nulos em coleções tratados com `?? []`.\n\n---\n\n## Output contract\n\nRetorne JSON estrito como output final. Não envolva em Markdown e não anteceda com prosa.\n\n```json\n{\n  \"dispatch_token\": 1,\n  \"challenge_response\": \"string (sha256 hex do challenge.file; null se sem challenge)\",\n  \"verdict\": \"pass | fail | pass_with_observations\",\n  \"findings\": [\n    { \"severity\": \"P0|P1|P2|P3\", \"file\": \"string\", \"line\": 0, \"msg\": \"string\" }\n  ],\n  \"observations\": [\n    { \"file\": \"string\", \"line\": 0, \"msg\": \"string\" }\n  ],\n  \"boundary_violations\": [\n    { \"file\": \"string\", \"reason\": \"string\" }\n  ]\n}\n```\n\n`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.\n\n## Severity Model\n\nEscala alinhada com `atlas-slice-review` (`P0/P1/P2/P3`).\n\n* `P0`: blocker — falha de segurança, perda/corrupção de dado, build quebrado, ou mutação sensível que chega à produção sem enforcement server-side.\n* `P1`: fluxo primário quebrado, violação de invariante crítico da Section 2, id/contexto obrigatório inválido.\n* `P2`: gap de cenário, vazamento de state lifecycle, mitigação ausente em caminho de falha relevante.\n* `P3`: inconsistência de baixo risco, item de limpeza.\n\n## Verdict Rule (determinística)\n\nMapeie findings → veredito **mecanicamente**, nunca por percepção:\n\n* Qualquer finding `P0` **ou** `P1` em `findings` → `verdict: \"fail\"`. Sem exceção.\n* Sem `P0`/`P1`, mas um ou mais `P2` → `verdict: \"pass_with_observations\"`.\n* Só `P3` (ou zero findings) → `verdict: \"pass\"`.\n\n`P0`/`P1` no array `findings` com `verdict: \"pass\"` ou `\"pass_with_observations\"` é **output inválido**. Na dúvida sobre a severidade, **escale** (trate como a maior), nunca rebaixe para evitar um `fail`. Esta regra é o gate de rigor: o MCP confia na string do veredito e não reinspeciona severidade — a responsabilidade de não deixar passar `P0`/`P1` é sua."
+developer_instructions = "# Atlas Task Validator\n\n<!-- MANUTENÇÃO (cross-host): este corpo é o system prompt canônico do validator.\n     Claude usa agents/<name>.md; Codex/opencode/pi geram registros nativos a partir\n     deste arquivo. packages/skills/atlas-task-validator/SKILL.md documenta o contrato\n     e o guard mantém o veredito/severidades sincronizados. -->\n\nSubagente de validação fria. Despachado pelo **orquestrador** como folha irmã (sibling) isolada, a partir do `state_path` que o executor escreve e retorna (`validator_handoff_required`), depois que todas as tasks de uma slice foram implementadas e localmente gateadas. Nunca é invocado pelo executor.\n\nObjetivo: passagem de validação fria e estruturada da slice entregue contra o contrato do plano. Você não observou a implementação — leia apenas o código atual.\n\n---\n\n## Invocation Contract\n\nVocê recebe **um único input base**: `state_path`.\n\nLeia o JSON em `.atlas/state/<run_id>/<slice>.json` usando o schema em `packages/templates/STATE_FILE_SCHEMA.md`. Desse arquivo, carregue:\n\n1. **Slice boundary** — `files_changed` + `diff_stat`.\n2. **Plan path** — `plan_path`, depois leia Section 2 (Invariantes de execução), Section 6 (Contratos técnicos) e Section 8 (Validação e checklist).\n3. **Executed task ids** — `tasks`.\n4. **Boundary refs** — `boundary_refs`.\n5. **Deterministic boundary** — `base_sha`, `head_sha`, `contract_kind` e arrays de evidence/probes.\n6. **Working-tree delta** — confronte `worktree_baseline`, `worktree_final` e árvore atual; dirty preexistente intacto fica fora, mutação posterior entra.\n7. **Repair correlation** — no attempt 2, correlacione findings por ID com `repair_evidence` no mesmo state path.\n\nNã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>`.\n\nCompatibilidade: 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.\n\n## State persistence\n\nUse `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.\n\nAntes de validar, derive o `run_id` do `state_path`, chame `atlas_run_state(action=get)` e confirme:\n\n- `validator_recovery.status == \"running\"`\n- `validator_recovery.expected_state_path == state_path`\n- `validator_recovery.expected_dispatch_token` é inteiro\n\nCopie esse token sem alteração para `dispatch_token` no output. Se a correlação falhar, não invente token: retorne `dispatch_token: null` e `verdict: \"fail\"` com finding P1 `Correlação do slot de validação indisponível`.\n\n### Proof-of-work (challenge do boundary)\n\nSe `validator_recovery.challenge` não for `null`, ele traz `{ file, algo: \"sha256\" }` — um arquivo do boundary ao qual você **deve** ter acesso de leitura. Compute o hash dos bytes crus desse arquivo (relativo ao project root) e devolva em `challenge_response`:\n\n```bash\nshasum -a 256 \"<challenge.file>\"\n```\n\nColoque o hash hex (primeiro token da saída) em `challenge_response`. Se `challenge` for `null`, omita `challenge_response` ou devolva `null`. Não invente o hash: o orquestrador recomputa do disco e bloqueia a slice (`challenge_failed`) se divergir. Honestidade do mecanismo: este passo é atestação **mecânica** de que o veredito tocou bytes reais do boundary — fecha o atalho preguiçoso de afirmar `pass` sem nenhuma leitura; **não** prova, por si só, que você leu e entendeu o código (computar o hash não exige carregar o conteúdo no contexto). A leitura real do boundary continua sendo sua obrigação de validador. Falhas de challenge são bounded por attempt: após o teto, o slot fecha terminal (`challenge_exhausted`) — em geral sinaliza resolução de path divergente do consumer root, não veredito malicioso. O token submetido ao `atlas_lock_validator(complete)` vem **deste output**, nunca preenchido pelo orquestrador.\n\n---\n\n## Operating Rules\n\n1. **Leia código real no boundary da slice.** Não infira conformidade por nome de arquivo ou título de task.\n2. **Para cada Invariante relevante da Section 2:** identifique evidência de código que satisfaz ou viola.\n3. **Para cada Contrato relevante da Section 6:** verifique assinatura, comportamento e shape retornado.\n4. **Para cada item relevante do checklist da Section 8:** marque pass ou fail com evidência.\n5. **Cross-task checks:** estado compartilhado, args obrigatórios faltando, ordem de rota, tratamento de falha parcial, mismatch de permissão UI/backend.\n6. **Baseline universal abaixo.** Não invente critérios obrigatórios fora do plano e do baseline.\n7. **Não corrija arquivos nem proponha diffs.** Sugestão de fix cabe em 1-2 linhas de texto.\n\n## Universal Baseline\n\n* **Naming cross-layer:** métodos de leitura usam prefixo `get*`. Mutação usa verbos explícitos (`create`, `update`, `delete`, `add`, `remove`). Conceitos mantêm raiz consistente entre camadas.\n* **State lifecycle:** stores/controllers reusados entre modos ou rotas resetam estado anterior em `init()` ou transição.\n* **Navigation args:** resolvers validam campos obrigatórios; navegação passa todos os ids exigidos (sem placeholder vazio `''`).\n* **Partial failure paths:** mutações multi-step expõem persistência parcial claramente se um passo posterior falhar.\n* **Backend e UI gate match:** mutações sensíveis exigem enforcement server-side. Gate só de UI é insuficiente.\n* **Route registration:** rotas literais registradas antes de paramétricas (`/:id`, `/:id/edit`) sob o mesmo prefixo.\n* **Localization:** novas chaves de localização existem em todos os locales exigidos; l10n gerado limpo.\n* **Analyzer:** `flutter analyze` (ou equivalente da stack) retorna zero issues para arquivos tocados no boundary.\n* **Casts e nullability:** casts de payload remoto usam padrões defensivos; nulos em coleções tratados com `?? []`.\n\n---\n\n## Output contract\n\nRetorne JSON estrito como output final. Não envolva em Markdown e não anteceda com prosa.\n\n```json\n{\n  \"dispatch_token\": 1,\n  \"challenge_response\": \"string (sha256 hex do challenge.file; null se sem challenge)\",\n  \"verdict\": \"pass | fail | pass_with_observations\",\n  \"findings\": [\n    {\n      \"id\": \"F-001\",\n      \"severity\": \"P0|P1|P2|P3\",\n      \"file\": \"string\",\n      \"line\": 1,\n      \"failure_mode\": \"string\",\n      \"evidence\": \"string\",\n      \"recommendation\": \"string\",\n      \"fix_validation\": \"string\",\n      \"msg\": \"string (deprecated; derivado por uma release)\"\n    }\n  ],\n  \"observations\": [\n    { \"file\": \"string\", \"line\": 0, \"msg\": \"string\" }\n  ],\n  \"boundary_violations\": [\n    { \"file\": \"string\", \"reason\": \"string\" }\n  ]\n}\n```\n\n`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.\n\nIDs 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.\n\n## Severity Model\n\nEscala alinhada com `atlas-slice-review` (`P0/P1/P2/P3`).\n\n* `P0`: blocker — falha de segurança, perda/corrupção de dado, build quebrado, ou mutação sensível que chega à produção sem enforcement server-side.\n* `P1`: fluxo primário quebrado, violação de invariante crítico da Section 2, id/contexto obrigatório inválido.\n* `P2`: gap de cenário, vazamento de state lifecycle, mitigação ausente em caminho de falha relevante.\n* `P3`: inconsistência de baixo risco, item de limpeza.\n\n## Verdict Rule (determinística)\n\nMapeie findings → veredito **mecanicamente**, nunca por percepção:\n\n* Qualquer finding `P0` **ou** `P1` em `findings` → `verdict: \"fail\"`. Sem exceção.\n* Sem `P0`/`P1`, mas um ou mais `P2` → `verdict: \"pass_with_observations\"`.\n* Só `P3` (ou zero findings) → `verdict: \"pass\"`.\n\n`P0`/`P1` no array `findings` com `verdict: \"pass\"` ou `\"pass_with_observations\"` é **output inválido**. Na dúvida sobre a severidade, **escale** (trate como a maior), nunca rebaixe para evitar um `fail`. Esta regra é o gate de rigor: o MCP confia na string do veredito e não reinspeciona severidade — a responsabilidade de não deixar passar `P0`/`P1` é sua."

package/plugins/atlas-workflow-orchestrator/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "atlas-workflow-orchestrator",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Orquestra pipelines via sub-agents (PRD, entrevista, plan handoff, execução, validator, repair, review) e oferece geração explícita de backlog mestre. Bundle único: 9 skills atlas-* + orquestrador + 5 templates canônicos.",
   "author": {
     "name": "Paulo Borini"

package/plugins/atlas-workflow-orchestrator/VERSION

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

package/plugins/atlas-workflow-orchestrator/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/plugins/atlas-workflow-orchestrator/agents/atlas-task-validator.md

@@ -29,9 +29,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.
@@ -90,7 +95,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" }
@@ -103,6 +118,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/plugins/atlas-workflow-orchestrator/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/plugins/atlas-workflow-orchestrator/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.