atlas-workflow 0.8.2

package/plugins/atlas-workflow-orchestrator/skills/atlas-plan-execute/scripts/check_budget_state.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""Track bounded repair attempts for a gated execution task."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+from dataclasses import dataclass, asdict
+
+
+@dataclass
+class BudgetState:
+    task_id: str
+    max_attempts: int = 2
+    max_same_failure: int = 2
+    attempts: int = 0
+    same_failure_count: int = 0
+    last_failure_key: str = ""
+    blocked: bool = False
+
+
+def load_state(path: pathlib.Path) -> BudgetState:
+    if not path.exists():
+        raise FileNotFoundError(f"State file not found: {path}")
+    return BudgetState(**json.loads(path.read_text(encoding="utf-8")))
+
+
+def save_state(path: pathlib.Path, state: BudgetState) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(asdict(state), indent=2) + "\n", encoding="utf-8")
+
+
+def cmd_init(args: argparse.Namespace) -> int:
+    state = BudgetState(
+        task_id=args.task_id,
+        max_attempts=args.max_attempts,
+        max_same_failure=args.max_same_failure,
+    )
+    save_state(pathlib.Path(args.state_file), state)
+    print(json.dumps(asdict(state), indent=2))
+    return 0
+
+
+def cmd_record(args: argparse.Namespace) -> int:
+    path = pathlib.Path(args.state_file)
+    state = load_state(path)
+    state.attempts += 1
+
+    if args.failure_key:
+        if args.failure_key == state.last_failure_key:
+            state.same_failure_count += 1
+        else:
+            state.last_failure_key = args.failure_key
+            state.same_failure_count = 1
+
+    if state.attempts >= state.max_attempts or state.same_failure_count >= state.max_same_failure:
+        state.blocked = True
+
+    save_state(path, state)
+    print(json.dumps(asdict(state), indent=2))
+    return 0
+
+
+def cmd_status(args: argparse.Namespace) -> int:
+    state = load_state(pathlib.Path(args.state_file))
+    print(json.dumps(asdict(state), indent=2))
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    init_parser = subparsers.add_parser("init")
+    init_parser.add_argument("state_file")
+    init_parser.add_argument("task_id")
+    init_parser.add_argument("--max-attempts", type=int, default=2)
+    init_parser.add_argument("--max-same-failure", type=int, default=2)
+    init_parser.set_defaults(func=cmd_init)
+
+    record_parser = subparsers.add_parser("record")
+    record_parser.add_argument("state_file")
+    record_parser.add_argument("--failure-key", default="")
+    record_parser.set_defaults(func=cmd_record)
+
+    status_parser = subparsers.add_parser("status")
+    status_parser.add_argument("state_file")
+    status_parser.set_defaults(func=cmd_status)
+
+    args = parser.parse_args()
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugins/atlas-workflow-orchestrator/skills/atlas-plan-execute/scripts/extract_plan_contract.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""Extract execution-relevant sections from a atlas-plan-handoff markdown artifact."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import re
+import sys
+from typing import Any
+
+HEADING_RE = re.compile(r"^(#{1,4})\s+(.*\S)\s*$")
+TASK_RE = re.compile(r"^T\d{2}\.\s+")
+
+
+def normalize_heading(text: str) -> str:
+    text = re.sub(r"^\d+\.\s*", "", text.strip())
+    text = re.sub(r"\(§\d+\)", "", text, flags=re.IGNORECASE)
+    return re.sub(r"[^a-z0-9]+", "_", text.lower()).strip("_")
+
+
+def has_any(summary: dict[str, list[str]], keys: list[str]) -> bool:
+    return any(key in summary for key in keys)
+
+
+def first_section(summary: dict[str, list[str]], keys: list[str]) -> list[str]:
+    for key in keys:
+        if key in summary:
+            return summary[key]
+    return []
+
+
+def parse_plan(text: str) -> dict[str, Any]:
+    sections: list[dict[str, Any]] = []
+    current: dict[str, Any] | None = None
+
+    for raw_line in text.splitlines():
+        line = raw_line.rstrip()
+        match = HEADING_RE.match(line)
+        if match:
+            level = len(match.group(1))
+            title = match.group(2).strip()
+            current = {
+                "level": level,
+                "title": title,
+                "key": normalize_heading(title),
+                "lines": [],
+            }
+            sections.append(current)
+            continue
+        if current is not None:
+            current["lines"].append(line)
+
+    tasks = []
+    for section in sections:
+        if section["level"] == 4 and TASK_RE.match(section["title"]):
+            tasks.append(
+                {
+                    "id": section["title"].split(".", 1)[0],
+                    "title": section["title"],
+                    "body": [line for line in section["lines"] if line.strip()],
+                }
+            )
+
+    summary = {section["key"]: [line for line in section["lines"] if line.strip()] for section in sections}
+    metadata = {
+        "plan_prefix": "",
+        "execution_mode": "",
+        "executor_skill": "",
+        "internal_validator": "",
+        "external_review": "",
+    }
+
+    metadata_section = first_section(
+        summary,
+        ["execution_metadata", "metadados_de_execu_o", "metadados_execu_o"],
+    )
+    for line in metadata_section:
+        lowered = line.lower()
+        if "plan prefix" in lowered:
+            metadata["plan_prefix"] = line.split(":", 1)[-1].strip().strip("`")
+        elif "execution mode" in lowered:
+            metadata["execution_mode"] = line.split(":", 1)[-1].strip().strip("`")
+        elif "executor skill" in lowered:
+            metadata["executor_skill"] = line.split(":", 1)[-1].strip().strip("`")
+        elif "internal validator" in lowered:
+            metadata["internal_validator"] = line.split(":", 1)[-1].strip().strip("`")
+        elif "external review" in lowered:
+            metadata["external_review"] = line.split(":", 1)[-1].strip().strip("`")
+
+    # Compact PLAN_TEMPLATE (sections 1–8); legacy aliases kept for older artifacts.
+    required_groups = {
+        "execution_metadata": ["execution_metadata", "metadados_de_execu_o", "metadados_execu_o"],
+        "executive_translation": [
+            "tradu_o_executiva",
+            "executive_summary",
+            "executive_translation",
+            "resumo_executivo",
+        ],
+        "execution_invariants": [
+            "invariantes_de_execu_o",
+            "invariantes_de_execu_o_derivados_do_prd",
+            "execution_invariants",
+        ],
+        "pitfalls": ["pitfalls"],
+        "sprint_opening_state": [
+            "estado_na_abertura_da_sprint",
+            "estado_na_abertura_da_sprint_pr_implementa_o",
+            "current_state_relevant_to_execution",
+            "estado_atual_relevante_para_execu_o",
+        ],
+        "execution_tasks": ["tarefas_de_execu_o", "execution_tasks", "tarefas"],
+        "technical_contracts": [
+            "contratos_t_cnicos",
+            "contratos_t_cnicos_s_ambiguidade_prd_c_digo",
+            "technical_contracts",
+        ],
+        "validation_checklist": [
+            "valida_o_e_checklist",
+            "valida_o_e_checklist_validator",
+            "validation_and_checklist",
+            "validation",
+            "valida_o",
+            "valida_o_final",
+        ],
+    }
+
+    optional_groups = {
+        "slices": ["slices", "slices_somente_se_execution_mode_orchestrated_per_slice"],
+        "open_questions_blockers": [
+            "perguntas_em_aberto_e_bloqueios_reais",
+            "open_questions_and_real_blockers",
+            "open_questions",
+            "real_blockers",
+        ],
+        # Legacy sections — extracted if present, never required.
+        "handoff_prompt": ["handoff_prompt", "executor_guidance"],
+        "legacy_scope": ["scope", "escopo"],
+        "legacy_architecture": [
+            "solution_design_and_architecture",
+            "design_e_arquitetura_da_solu_o",
+        ],
+    }
+
+    missing = [name for name, aliases in required_groups.items() if not has_any(summary, aliases)]
+
+    execution_mode = metadata.get("execution_mode", "").lower()
+    if "orchestrated" in execution_mode and not has_any(summary, optional_groups["slices"]):
+        missing.append("slices")
+
+    return {
+        "sections": [
+            {"title": section["title"], "key": section["key"], "level": section["level"]}
+            for section in sections
+        ],
+        "tasks": tasks,
+        "missing_required_sections": missing,
+        "execution_metadata": metadata,
+        "summary": {
+            "execution_metadata": metadata_section,
+            "executive_translation": first_section(summary, required_groups["executive_translation"]),
+            "execution_invariants": first_section(summary, required_groups["execution_invariants"]),
+            "pitfalls": first_section(summary, required_groups["pitfalls"]),
+            "sprint_opening_state": first_section(summary, required_groups["sprint_opening_state"]),
+            "execution_tasks": first_section(summary, required_groups["execution_tasks"]),
+            "technical_contracts": first_section(summary, required_groups["technical_contracts"]),
+            "validation_checklist": first_section(summary, required_groups["validation_checklist"]),
+            "slices": first_section(summary, optional_groups["slices"]),
+            "open_questions_blockers": first_section(
+                summary, optional_groups["open_questions_blockers"]
+            ),
+            "handoff_prompt": first_section(summary, optional_groups["handoff_prompt"]),
+        },
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("plan", help="Path to a markdown plan artifact")
+    args = parser.parse_args()
+
+    plan_path = pathlib.Path(args.plan)
+    payload = parse_plan(plan_path.read_text(encoding="utf-8"))
+    json.dump(payload, sys.stdout, indent=2)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugins/atlas-workflow-orchestrator/skills/atlas-plan-execute/scripts/validate_gate_result.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Classify a gate outcome into pass, fixable, or blocked."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import sys
+from typing import Any
+
+
+def load_json(path: pathlib.Path) -> dict[str, Any]:
+    if not path.exists():
+        raise FileNotFoundError(f"JSON file not found: {path}")
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("gate_result", help="JSON file describing the gate outcome")
+    parser.add_argument("--budget-state", help="Optional budget state JSON file")
+    args = parser.parse_args()
+
+    try:
+        payload = load_json(pathlib.Path(args.gate_result))
+        budget = load_json(pathlib.Path(args.budget_state)) if args.budget_state else {}
+    except FileNotFoundError as exc:
+        sys.stderr.write(f"{exc}\n")
+        return 1
+
+    failed_checks = payload.get("failed_checks", [])
+    invariant_breaks = payload.get("invariant_breaks", [])
+    external_blockers = payload.get("external_blockers", [])
+    diff_attributed = payload.get("diff_attributed", True)
+
+    if external_blockers or budget.get("blocked"):
+        status = "blocked"
+    elif failed_checks or invariant_breaks:
+        status = "fixable" if diff_attributed else "blocked"
+    else:
+        status = "pass"
+
+    result = {
+        "status": status,
+        "failed_checks": failed_checks,
+        "invariant_breaks": invariant_breaks,
+        "external_blockers": external_blockers,
+        "diff_attributed": diff_attributed,
+    }
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugins/atlas-workflow-orchestrator/skills/atlas-plan-handoff/SKILL.md

@@ -0,0 +1,181 @@
+---
+name: atlas-plan-handoff
+description: Skill `atlas-plan-handoff`. Produz um handoff executável da família Atlas, fechando prefixo, modo de execução e gates no próprio artefato para consumo por `atlas-plan-execute` e `atlas-slice-review`.
+---
+
+# Atlas Plan Handoff
+
+Use esta skill quando o usuário pedir um plano executável da cadeia `atlas-*`.
+
+O artefato segue `PLAN_TEMPLATE.md` e `BOUNDARY_PRD_PLAN.md` — **localize ambos em `<raiz-do-plugin>/packages/templates/`**. O plano **não** depende de memória do chat para prefixo, modo ou executor.
+
+## Resolução Canônica de Templates
+
+* Fonte única: `packages/templates/` empacotado no plugin Atlas Workflow.
+* Resolver `PLAN_TEMPLATE.md` e `BOUNDARY_PRD_PLAN.md` a partir da raiz do plugin/bundle, antes de olhar qualquer arquivo do repo consumidor.
+* Template local do repo consumidor nunca sobrepõe o template empacotado.
+* Se `packages/templates/PLAN_TEMPLATE.md` ou `packages/templates/BOUNDARY_PRD_PLAN.md` não existir, abortar com erro claro: `Template canônico ausente: <nome-do-template>`.
+* Não usar fallback silencioso para cópias antigas, vault local ou templates globais.
+
+## State persistence
+
+Use `atlas_run_state` como fonte primária de estado da run. Não leia/escreva estado por file IO direto. Se o MCP estiver indisponível, avise que o gate não pode ser comprovado e aborte a fase em vez de seguir por fallback narrativo.
+
+## Plan path resolution
+
+Os paths são fornecidos pelo adapter de host: consultar `atlas_capabilities` e ler `plan_paths` (`write` + `read_order`). Referência canônica: `packages/orchestrator/references/host-adapters.md`. Valores atuais (iguais em todo host):
+
+Escrita de novos planos: somente `.atlas/plans/`.
+
+Leitura/migração por 1 release (ordem de `plan_paths.read_order`):
+
+1. `.atlas/plans/`
+2. `.cursor/plans/` com warning de depreciação
+3. `.codex/plans/` com warning de depreciação
+
+Se um plano legado for lido, o próximo artefato gerado deve ser salvo em `.atlas/plans/`.
+
+## Cadeia de execução
+
+```text
+atlas-plan-handoff → atlas-plan-execute → atlas-task-validator → atlas-slice-review (opcional, via `--review`)
+```
+
+No workflow `full`, `atlas-plan-handoff` é autoria documental do agente principal/orquestrador. O primeiro sub-agent da cadeia só nasce em `atlas-plan-execute`.
+
+---
+
+## Fluxo obrigatório
+
+1. **Classificação da tarefa:** feature, ui, contract, navigation, shared, security, diagnostic, refactoring, testing. Leia `project-rules/index/<tipo>.md` e regras em `project-rules/rules/` (ou equivalente do repo ativo).
+2. **Grounding no código:** confirme padrões, contratos e comandos locais (`flutter analyze` / `flutter test` com path do package) antes de inferir.
+3. **Decisões estáveis:** sanar bloqueios com perguntas ao usuário; registrar no plano (não recopiar tabela D* do PRD — referenciar `PRD §3`).
+4. **Escrita:** artefato markdown no path canônico `.atlas/plans/`. Teto orientativo ~250–350 linhas (até ~450 com slices).
+
+---
+
+## Metadados obrigatórios (topo do artefato)
+
+```md
+## Metadados de execução
+- Plan prefix: `atlas`
+- Execution mode: `sequencial (T01→TN)` | `orchestrated-per-slice`
+- Executor skill: `atlas-plan-execute`
+- Internal validator: `atlas-task-validator`
+- External review: `atlas-slice-review` (optional)
+```
+
+Regras:
+
+- `Plan prefix` é sempre `atlas`.
+- Se o modo não estiver decidido, o plano **não** está pronto para execução.
+- Deixe explícito por que o modo escolhido é adequado, checks por task vs fechamento de slice e quando parar em `blocked`.
+
+---
+
+## Estrutura do plano (seções 1 a 8)
+
+### 1. Tradução executiva
+
+- O que será implementado e o resultado observável técnico.
+- Padrão de referência no monorepo e tabela **referência vs esta entrega** (ligar a `PRD §3` D*, não recopiar a tabela).
+- Link ao PRD: `PRD §2` escopo, `PRD §3` decisões.
+
+### 2. Invariantes de execução (derivados do PRD)
+
+- Invariantes técnicos inegociáveis (ex.: sem refetch ao filtrar).
+- Referenciar IDs: `PRD §3 D12` — não colar a tabela D* inteira.
+
+### 3. Pitfalls
+
+- `anti-padrão observado` → `padrão canônico correto` (ancorado no repo).
+
+### 4. Estado na abertura da sprint (pré-implementação)
+
+- 3–6 bullets sobre o código hoje (comportamento/ausência — não inventário global de arquivos).
+- Se já implementado: tratar como checklist de verificação.
+
+### 5. Tarefas de execução
+
+Tarefas `#### T01.` … `#### TNN.` com schema de `BOUNDARY_PRD_PLAN.md` canônico empacotado:
+
+- **Objetivo**
+- **Referência** (módulo/padrão no monorepo — evite listas longas de paths; o executor descobre no repo)
+- **Pré-condições**
+- **Mudança esperada**
+- **Invariantes preservados**
+- **Não mudar** / **Não fazer**
+- **Dependências**
+- **Riscos** (se não óbvio)
+- **Critério de done**
+- **Validação local** (comando com path do package)
+- **Quality gates** (opcional em tasks críticas)
+- **Casos mínimos** (somente em tasks de teste)
+
+Última task típica: **Validação final** (`flutter analyze`, `flutter test`, passos manuais alinhados a **PRD §4–6**).
+
+### 6. Contratos técnicos (só ambiguidade PRD → código)
+
+- Assinaturas, shapes e mapeamentos onde o PRD §5 não fecha implementação.
+
+### 7. Slices (somente se `execution_mode: orchestrated-per-slice`)
+
+- Tabela: slice, tasks, objetivo, boundary de diff esperado.
+
+### 8. Validação e checklist (validator)
+
+- Critérios derivados de **PRD §6** + invariantes **§2** deste plano.
+- Título recomendado: `## 8. Validação e checklist (validator)`.
+- Comandos globais de analyze/test do package.
+
+---
+
+## Seção opcional
+
+### 9. Perguntas em aberto e bloqueios reais
+
+- Só bloqueios que impedem execução segura. O executor **para** se houver itens ativos aqui.
+- **Não** confundir com PRD §7 Apêndice (Referências).
+
+---
+
+## O que NÃO incluir (propositalmente)
+
+- Handoff prompt final no artefato (o executor lê o arquivo; ver `BOUNDARY_PRD_PLAN.md` no repo ativo).
+- Gate de prontidão do autor do plano.
+- Lista integral de rules do `project-rules` (o executor carrega via `AGENTS.md`).
+- Cópia integral do escopo/fora de escopo do PRD.
+- Inventário global de todos os arquivos tocados.
+
+---
+
+## Uso standalone vs protocolo interno no workflow (PRD D10/D11)
+
+Esta skill é de **autoria documental** (redigir um `PLAN_*.md`). A fronteira de determinismo do Atlas é a **mutação de código** (PRD D10): como redigir um plano não muta código, **autoria é livre, execução é gateada**.
+
+### (a) Uso standalone permitido
+
+Você pode invocar `atlas-plan-handoff` diretamente, fora do pipeline, para escrever um plano. Não há restrição: autoria documental não muta o produto. O `PLAN_*.md` resultante é livre para existir e ser editado.
+
+### (b) O artefato NÃO é confiável só por existir
+
+Um plano escrito standalone **não vale como gate aprovado** só porque existe — nem mesmo com nome `PLAN_*.md`. Ao entrar em execução (modos `full`/`direct`/`execute`), o plano é **re-gateado obrigatoriamente** por `atlas_verify_artifact` + `atlas_verify_template_conformance` (TC); no modo `execute`, essa reverificação na entrada é o equivalente ao gate pós-plano (PRD D13). Plano velho, manual, renomeado ou fora de conformidade **trava na entrada da execução**, não na autoria. Esta skill não declara o plano "executável de forma determinística" só por tê-lo escrito.
+
+### (c) Standalone vs protocolo interno no workflow
+
+- **Standalone:** o usuário conduz a skill diretamente; o produto é o `PLAN_*.md`, sujeito a re-validação na entrada de execução.
+- **No workflow:** quem conduz a fase de plano é o **orquestrador principal** (agente principal), que despacha/autora o plano antes de validá-lo e roda os gates MCP. Uma vez que o plano passa `atlas_verify_artifact` + TC, o orquestrador fica de mãos atadas (não edita mais o plano). A skill é a mesma; o que muda é quem orquestra e os gates que cercam a fase.
+
+> **Invariante:** autoria é livre, execução é gateada. Um plano só vira confiável para execução após `atlas_verify_artifact` + TC na entrada (PRD D11).
+
+---
+
+## Consistência da cadeia
+
+O próximo agente, só lendo o artefato, deve saber:
+
+- usar apenas skills `atlas-*` declaradas nos metadados;
+- respeitar `execution_mode`;
+- rodar `atlas-task-validator` antes de fechar a slice;
+- usar `atlas-slice-review` como segunda camada fria, não substituto do validator interno;
+- cruzar aceite de negócio com **PRD §4–6** quando o checklist do §8 for fino.

package/plugins/atlas-workflow-orchestrator/skills/atlas-plan-handoff/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "Atlas Plan Handoff"
+  short_description: "Handoff executável da família atlas-* com prefixo e modo fechados"
+  default_prompt: "Use $atlas-plan-handoff para produzir um plano executável da cadeia atlas-* com prefixo fechado, execution mode explícito, executor correto, validator interno obrigatório e review externo opcional."
+
+policy:
+  allow_implicit_invocation: true

package/plugins/atlas-workflow-orchestrator/skills/atlas-prd-interview/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: atlas-prd-interview
+description: Skill `atlas-prd-interview`. Use quando o usuário quer validar, interrogar ou amadurecer um PRD antes do planejamento ou implementação. Esta skill lê o PRD, cruza-o com código e contratos, detecta ambiguidades/discrepâncias, faz perguntas de múltipla escolha e para quando não restam gaps bloqueadores.
+---
+
+# PRD Interview (Atlas)
+
+Valide maturidade de PRD por entrevista guiada antes do planejamento ou implementação técnica. Não gere o PRD do zero. Não avance para o planejamento enquanto houver bloqueadores ativos (`❌`).
+
+## Resolução Canônica de Templates
+
+* Fonte única: `packages/templates/` empacotado no plugin Atlas Workflow.
+* Antes da entrevista, resolver `PRD_TEMPLATE.md` a partir da raiz do plugin/bundle.
+* Template local do repo consumidor nunca sobrepõe o template empacotado.
+* Se `packages/templates/PRD_TEMPLATE.md` não existir, abortar com erro claro: `Template canônico ausente: PRD_TEMPLATE.md`.
+* Não usar fallback silencioso para cópias antigas, vault local ou templates globais.
+
+---
+
+## Escopo da Skill
+
+Ataque principalmente as seguintes seções do template de PRD:
+* **§3 Decisões de produto (fechadas)**
+* **§4 Fluxos e cenários UX**
+* **§5 Contrato funcional e invariantes** (regras de negócio + contrato de dados)
+* **§6 Critérios de aceite (negócio)**
+
+---
+
+## Workflow Obrigatório
+
+1. **Leitura e Inspecção:** Leia o PRD e cruze com o código do repositório para verificar discrepâncias físicas reais (se componentes, rotas e APIs descritos batem com a codebase).
+2. **Mapeamento de Gaps:** Classifique cada lacuna como:
+   * `✅` **Completo:** Decisão suficiente e verificável.
+   * `⚠️` **Pendente:** Falta detalhe de negócio que pode ser resolvido depois (não-bloqueante).
+   * `❌` **Bloqueador:** Ambiguidade, conflito com o código ou falta de fluxo de UX crítico que impede o planejamento de engenharia.
+
+**Mapeamento por Seções (Novo Template):**
+* **§3 Decisões de produto (fechadas):** `❌` se faltar decisão que altere fluxo principal, mappers, roteamento ou comportamento crítico.
+* **§4 Fluxos e cenários UX:** `❌` se impactar o fluxo principal e faltarem os caminhos de loading, erro, vazio ou permissões.
+* **§5 Contrato funcional e invariantes:** `❌` se campos críticos não possuírem regras de formato (ex: decimais) ou se a regra de negócio for ambígua/impossível de verificar na codebase.
+* **§6 Critérios de aceite (negócio):** `❌` se o critério for subjetivo, não observável ou não testável.
+
+3. **Perguntas por Rodada (AskUserQuestion):** Formule rodadas de no máximo 4 perguntas concisas via ferramenta nativa `AskUserQuestion`, com exatamente 3 opções e indicando a recomendada. **Pare o turno e aguarde a resposta.**
+4. **Veredito Final:** Só emita o veredito de `Pronto para planejamento` quando zerar todos os `❌`.
+
+---
+
+## Índice Provisório (fim de cada rodada)
+
+```text
+§3 Decisões:      ✅/⚠️/❌
+§4 Experiência:   ✅/⚠️/❌
+§5 Contrato+inv:  ✅/⚠️/❌
+§6 Aceite:        ✅/⚠️/❌
+```
+
+---
+
+## Uso standalone vs protocolo interno no workflow (PRD D10/D11)
+
+Esta skill é de **autoria documental** (maturar um PRD). A fronteira de determinismo do Atlas é a **mutação de código** (PRD D10): como esta skill não muta código, **autoria é livre, execução é gateada**.
+
+### (a) Uso standalone permitido
+
+Você pode invocar `atlas-prd-interview` diretamente, fora do pipeline, para amadurecer um PRD. Não há restrição: autoria documental não muta o produto. O artefato resultante (`PRD_*.md`) é livre para existir e ser editado.
+
+### (b) O artefato NÃO é confiável só por existir
+
+Um PRD amadurecido standalone **não vale como gate aprovado** pelo simples fato de existir. Ao entrar em execução (modos `full`/`direct`/`execute`), ele é **re-gateado obrigatoriamente** por `atlas_verify_artifact` + `atlas_verify_template_conformance` (TC). PRD velho, manual ou inválido **trava na entrada da execução**, não na autoria. Esta skill não emite veredito de execução nem declara o PRD "pronto para implementar de forma determinística".
+
+### (c) Standalone vs protocolo interno no workflow
+
+- **Standalone:** o usuário conduz a skill diretamente; o produto é o PRD maturado, sujeito a re-validação posterior.
+- **No workflow:** quem conduz a fase de PRD é o **orquestrador principal** (agente principal), que decide quando entrevistar (scan de ambiguidade / `--interview`) e roda os gates MCP do pipeline. A skill é a mesma; o que muda é quem orquestra e os gates que cercam a fase.
+
+> **Invariante:** autoria é livre, execução é gateada. Um PRD só vira confiável para execução após `atlas_verify_artifact` + TC na entrada (PRD D11).

package/plugins/atlas-workflow-orchestrator/skills/atlas-prd-interview/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "Atlas PRD Interview"
+  short_description: "Entrevista e saneia ambiguidades de PRD"
+  default_prompt: "Use $atlas-prd-interview para validar este PRD, cruzar com o código e fechar ambiguidades críticas em rodadas curtas de múltipla escolha."
+
+policy:
+  allow_implicit_invocation: true