atlas-workflow 0.9.3 → 0.9.4

package/plugins/atlas-workflow-orchestrator/packages/mcp-server/server.js

@@ -64,11 +64,12 @@ const WORKFLOW_CONFIG = {
     plan_handoff: 'atlas-plan-handoff',
     plan_execute: 'atlas-plan-execute',
     direct_execute: 'atlas-direct-execute',
+    audit: 'atlas-audit',
     findings_repair: 'atlas-findings-repair',
     slice_review: 'atlas-slice-review',
     task_validator: 'atlas-task-validator',
   },
-  modes: ['full', 'direct', 'execute', 'interview-only', 'interview_only'],
+  modes: ['full', 'direct', 'execute', 'interview-only', 'interview_only', 'audit'],
 };
 
 const VALIDATOR_MAX_ATTEMPTS = 2;
@@ -104,7 +105,7 @@ function repairRunId(runId, attempt, timestamp) {
 // pipelines completas (full/direct/execute) declaram full_pipeline; uso avulso
 // documental/leitura declara reduced_standalone (fora do escopo desta camada).
 // Data-driven: rota → nível, sem ramo solto. Modos sem execução de código
-// (interview-only) NÃO declaram guarantee_level (não há execução a garantir):
+// (interview-only/audit) NÃO declaram guarantee_level (não há execução a garantir):
 // guaranteeLevelForMode devolve null e o campo é OMITIDO do output (PRD D2/D12).
 const GUARANTEE_LEVELS = ['full_pipeline', 'reduced_standalone'];
 const MODE_GUARANTEE_LEVEL = {
@@ -1160,6 +1161,16 @@ function runState(args = {}) {
   throw rpcError(-32602, `Ação inválida para atlas_run_state: ${action}`);
 }
 
+function validateJsonArtifactFile(absolutePath) {
+  try {
+    const content = fs.readFileSync(absolutePath, 'utf8');
+    const parsed = JSON.parse(content);
+    return { ok: true, parsed_type: Array.isArray(parsed) ? 'array' : typeof parsed };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
 function verifyArtifact(args = {}) {
   const runId = validateRunId(args.run_id);
   const artifactPath = requiredString(args, 'artifact_path');
@@ -1172,7 +1183,9 @@ function verifyArtifact(args = {}) {
   const artifactKind = optionalString(args, 'artifact_kind');
   const okBanner = artifactKind === 'prd'
     ? renderBanner('prd_ok', {})
-    : renderBanner('plano', {});
+    : artifactKind === 'json'
+      ? renderBanner('validacao', { status: 'json_ok' })
+      : renderBanner('plano', {});
   let result;
 
   try {
@@ -1189,15 +1202,43 @@ function verifyArtifact(args = {}) {
       };
     } else {
       fs.accessSync(absolutePath, fs.constants.R_OK);
-      result = {
-        gate: 'G1',
-        status: 'passed',
-        artifact_path: artifactPath,
-        bytes: stat.size,
-        timestamp,
-        banner: okBanner,
-        next_action: 'avançar',
-      };
+      if (artifactKind === 'json') {
+        const jsonCheck = validateJsonArtifactFile(absolutePath);
+        if (!jsonCheck.ok) {
+          result = {
+            gate: 'G1',
+            status: 'blocked',
+            artifact_path: artifactPath,
+            bytes: stat.size,
+            timestamp,
+            banner: renderBanner('preflight_fail', { motivo: `json inválido: ${artifactPath}` }),
+            error: `Artefato JSON inválido: ${artifactPath}`,
+            cause: jsonCheck.error,
+            next_action: 'corrigir_json_ou_regenerar_por_serializer',
+          };
+        } else {
+          result = {
+            gate: 'G1',
+            status: 'passed',
+            artifact_path: artifactPath,
+            bytes: stat.size,
+            parsed_type: jsonCheck.parsed_type,
+            timestamp,
+            banner: okBanner,
+            next_action: 'avançar',
+          };
+        }
+      } else {
+        result = {
+          gate: 'G1',
+          status: 'passed',
+          artifact_path: artifactPath,
+          bytes: stat.size,
+          timestamp,
+          banner: okBanner,
+          next_action: 'avançar',
+        };
+      }
     }
   } catch (error) {
     result = {
@@ -1819,6 +1860,7 @@ function expectedNextPhase(routing, dispatch) {
   if (routing.mode === 'full') return 'plan_handoff';
   if (routing.mode === 'direct') return 'plan_execute';
   if (routing.mode === 'execute') return 'plan_execute';
+  if (routing.mode === 'audit') return 'audit_report';
   return 'prd_interview';
 }
 
@@ -2764,6 +2806,7 @@ function validatorComplete(args, context) {
   // validator. Sem token não existe garantia anti-stale completa.
   const dispatchToken = optionalInteger(args, 'dispatch_token');
   const challengeResponse = optionalString(args, 'challenge_response');
+  const validatorOutputPath = optionalString(args, 'validator_output_path');
 
   if (!cycle.active) {
     // S10: slot já fechado. Distinguir retorno duplicado já aplicado (idempotente
@@ -2934,6 +2977,28 @@ function validatorComplete(args, context) {
   }
   const challengeVerified = !cycle.active.challenge ? 'no_challenge' : 'verified';
 
+  if (validatorOutputPath) {
+    const outputPath = resolveConsumerPath(validatorOutputPath, args);
+    const jsonCheck = validateJsonArtifactFile(outputPath);
+    if (!jsonCheck.ok) {
+      return {
+        gate: 'G4',
+        action: 'complete',
+        status: 'blocked',
+        timestamp,
+        validator_attempt: cycle.active.attempt,
+        validator_run_id: activeValidatorRunId,
+        state_path: statePathValue,
+        validator_output_path: validatorOutputPath,
+        validator_status: 'invalid_validator_output_json',
+        error: `Output JSON do validator inválido: ${validatorOutputPath}`,
+        cause: jsonCheck.error,
+        impact: 'relatorio_do_validador_nao_e_parseavel_como_json_confiavel',
+        next_action: 'regenerar_validator_output_json_por_serializer_e_reenviar_complete',
+      };
+    }
+  }
+
   if (packetResult.violations.length > 0) {
     return {
       gate: 'G4', action: 'complete', status: 'blocked', timestamp,
@@ -3605,7 +3670,7 @@ function toolsList() {
             run_id: { type: 'string', minLength: 1 },
             project_root: { type: 'string', minLength: 1 },
             artifact_path: { type: 'string', minLength: 1 },
-            artifact_kind: { enum: ['prd', 'plan'] },
+            artifact_kind: { enum: ['prd', 'plan', 'json'] },
           },
         },
       },
@@ -3655,7 +3720,7 @@ function toolsList() {
       },
       {
         name: 'atlas_preflight',
-        description: 'Gate PREREQ+G10: hard-fail de pré-requisitos de determinismo (subagente/MCP do host, DEC-004), depois valida modo, versão e lock ativo, travando a rota da run. Output declara guarantee_level (enum full_pipeline|reduced_standalone).',
+        description: 'Gate PREREQ+G10: hard-fail de pré-requisitos de determinismo (subagente/MCP do host, DEC-004), depois valida modo, versão e lock ativo, travando a rota da run. Output declara guarantee_level só em modos com execução.',
         inputSchema: {
           type: 'object',
           additionalProperties: false,
@@ -3724,6 +3789,7 @@ function toolsList() {
             repair_run_id: { type: 'string' },
             dispatch_token: { type: 'integer' },
             challenge_response: { type: 'string' },
+            validator_output_path: { type: 'string' },
             verdict: { type: 'string', enum: ['pass', 'pass_with_observations', 'fail'] },
             data: { type: 'object', additionalProperties: true },
             host: { type: 'string', enum: HOST_NAMES },

package/plugins/atlas-workflow-orchestrator/packages/skills/_shared/references/stack-profiles.md

@@ -33,4 +33,40 @@ Ativação é determinística: inspecione manifests no boundary e comandos realm
 - parsing/typing nas fronteiras e mutabilidade de defaults;
 - `pytest`, `ruff`, `mypy` ou equivalente apenas se declarados.
 
+## Go — `go.mod` ou comando Go real
+
+- context propagation/cancelamento, goroutine leak, data race e cleanup;
+- erros retornados sem swallow, wrapping útil e validação em fronteiras;
+- `go test`, `go vet`, `go test -race` e linters somente quando declarados/aplicáveis.
+
+## Rust — `Cargo.toml` ou comando Cargo real
+
+- ownership/lifetime usados para segurança real, não wrappers desnecessários;
+- `Result`/`Option` tratados sem `unwrap`/`expect` em fronteiras recuperáveis;
+- `cargo test`, `cargo check`, `cargo clippy` e `cargo fmt` somente quando declarados/aplicáveis.
+
+## Java/Kotlin — Maven/Gradle ou comando Java/Kotlin real
+
+- nullability, exceptions, resource cleanup e lifecycle de threads/coroutines;
+- boundaries de DTO/entity, serialização e validação de input;
+- `mvn test`, `gradle test`, linters/typecheck somente quando declarados.
+
+## Firebase — `firebase.json`, `.firebaserc` ou dependência Firebase real
+
+- regras/claims/authz, paths e ownership de dados;
+- falhas offline/retry, listeners/subscriptions e cleanup;
+- emuladores/deploy/checks somente quando declarados.
+
+## Supabase — dependência Supabase real
+
+- RLS/auth claims, schema/migrations, RPC/Edge Functions e storage policies;
+- sessão/token refresh, SSR/cookies quando aplicável e boundaries de dados;
+- CLI/migration/testes somente quando declarados.
+
+## REST/OpenAPI — OpenAPI/Swagger ou servidor/cliente HTTP real
+
+- compatibilidade request/response, status codes, paginação, erros e idempotência;
+- validação runtime nas bordas e divergência entre contrato e implementação;
+- geração/validação OpenAPI somente quando declarada.
+
 Perfis podem coexistir em monorepo. Regra de perfil nunca vira finding fora do boundary onde seu sinal foi ativado.

package/plugins/atlas-workflow-orchestrator/packages/skills/_shared/scripts/document_quality.mjs

@@ -10,7 +10,11 @@ const VALID = Object.freeze({
   state: new Set(['backlog', 'ready', 'doing', 'review', 'done', 'blocked']),
 });
 
-const STACK_MANIFESTS = ['package.json', 'tsconfig.json', 'pubspec.yaml', 'pyproject.toml', 'requirements.txt', 'setup.py'];
+const STACK_MANIFESTS = [
+  'package.json', 'tsconfig.json', 'pubspec.yaml', 'pyproject.toml', 'requirements.txt', 'setup.py',
+  'go.mod', 'Cargo.toml', 'pom.xml', 'build.gradle', 'build.gradle.kts', 'settings.gradle', 'settings.gradle.kts',
+  'firebase.json', '.firebaserc', 'openapi.yaml', 'openapi.yml', 'openapi.json', 'swagger.yaml', 'swagger.yml', 'swagger.json',
+];
 
 function boundaryRoot(projectRoot, boundary) {
   const project = path.resolve(projectRoot);
@@ -47,6 +51,9 @@ function containsGetxImport(root) {
 
 function detectBoundaryProfile(root, declaredCommands) {
   const exists = (name) => fs.existsSync(path.join(root, name));
+  const readIfExists = (name) => {
+    try { return exists(name) ? fs.readFileSync(path.join(root, name), 'utf8') : ''; } catch { return ''; }
+  };
   const commands = declaredCommands.filter((v) => typeof v === 'string');
   let packageJson = null;
   if (exists('package.json')) {
@@ -57,13 +64,36 @@ function detectBoundaryProfile(root, declaredCommands) {
     try { pubspec = fs.readFileSync(path.join(root, 'pubspec.yaml'), 'utf8'); } catch {}
   }
   const packageCommands = Object.values(packageJson?.scripts ?? {}).filter((v) => typeof v === 'string');
+  const packageDeps = Object.keys({
+    ...(packageJson?.dependencies ?? {}),
+    ...(packageJson?.devDependencies ?? {}),
+    ...(packageJson?.peerDependencies ?? {}),
+    ...(packageJson?.optionalDependencies ?? {}),
+  });
+  const cargo = readIfExists('Cargo.toml');
+  const pom = readIfExists('pom.xml');
+  const gradle = `${readIfExists('build.gradle')}\n${readIfExists('build.gradle.kts')}\n${readIfExists('settings.gradle')}\n${readIfExists('settings.gradle.kts')}`;
   const allCommands = [...commands, ...packageCommands];
   const hasCommand = (re) => allCommands.some((command) => re.test(command));
+  const hasPackageDep = (re) => packageDeps.some((dep) => re.test(dep));
+  const javaKotlinSignal = exists('pom.xml') || exists('build.gradle') || exists('build.gradle.kts')
+    || exists('settings.gradle') || exists('settings.gradle.kts') || hasCommand(/\b(gradle|mvn|java|javac|kotlinc)\b/);
+  const restSignal = exists('openapi.yaml') || exists('openapi.yml') || exists('openapi.json')
+    || exists('swagger.yaml') || exists('swagger.yml') || exists('swagger.json')
+    || hasPackageDep(/\b(openapi|swagger|express|fastify|koa|hono|axios|ky)\b/i)
+    || /openapi|swagger|spring-boot-starter-web|ktor|retrofit/i.test(`${pom}\n${gradle}\n${pubspec}`);
   return {
     universal: true,
     flutter_dart: exists('pubspec.yaml') || hasCommand(/\b(flutter|dart)\b/),
     node_typescript: exists('package.json') || exists('tsconfig.json') || hasCommand(/\b(node|npm|pnpm|yarn|bun|tsc)\b/),
     python: exists('pyproject.toml') || exists('requirements.txt') || exists('setup.py') || hasCommand(/\b(python3?|pytest|ruff|mypy)\b/),
+    go: exists('go.mod') || hasCommand(/\bgo\s+(test|build|run|vet|fmt)\b/),
+    rust: exists('Cargo.toml') || hasCommand(/\bcargo\s+(test|build|run|check|clippy|fmt)\b/) || /^\s*\[package\]/m.test(cargo),
+    java_kotlin: javaKotlinSignal,
+    firebase: exists('firebase.json') || exists('.firebaserc') || hasPackageDep(/^firebase$|^@firebase\/|firebase-admin/i)
+      || /firebase_core|cloud_firestore|firebase_auth|firebase_messaging|firebase_storage/i.test(pubspec),
+    supabase: hasPackageDep(/^@supabase\/|supabase-js/i) || /supabase_flutter|supabase|postgrest/i.test(pubspec),
+    rest_openapi: restSignal,
     getx: /^\s{0,4}get\s*:/m.test(pubspec) || containsGetxImport(root),
   };
 }
@@ -80,6 +110,12 @@ export function detectStackProfiles(root, declaredCommands = [], boundaryPaths =
     flutter_dart: boundaries.some((profile) => profile.flutter_dart),
     node_typescript: boundaries.some((profile) => profile.node_typescript),
     python: boundaries.some((profile) => profile.python),
+    go: boundaries.some((profile) => profile.go),
+    rust: boundaries.some((profile) => profile.rust),
+    java_kotlin: boundaries.some((profile) => profile.java_kotlin),
+    firebase: boundaries.some((profile) => profile.firebase),
+    supabase: boundaries.some((profile) => profile.supabase),
+    rest_openapi: boundaries.some((profile) => profile.rest_openapi),
     getx: boundaries.some((profile) => profile.getx),
     boundaries,
   };

package/plugins/atlas-workflow-orchestrator/packages/skills/atlas-audit/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: atlas-audit
+description: Skill/mode universal de auditoria Atlas. Use para `/workflow audit <target>` com flags opcionais `--handoff` e `--scope <descrição>`. Audita código contra regras locais, boas práticas da stack detectada e complexidade acidental estilo Ponytail, sem corrigir código nem executar plano.
+---
+
+# Atlas Audit
+
+Auditoria universal, framework-agnóstica. Esta skill lê o repositório real, audita o `target` informado e entrega relatório de achados. Opcionalmente gera handoff Atlas-style para correção futura. **Nunca altera código. Nunca executa plano.**
+
+## Sintaxe
+
+```text
+/workflow audit <target>
+/workflow audit <target> --handoff
+/workflow audit <target> --scope <descrição>
+```
+
+`target` pode ser arquivo, diretório, pacote, módulo, feature, PRD/plano como referência ou descrição que aponte para um boundary localizável. Se não for possível resolver o boundary em disco, pare e peça um target mais preciso.
+
+## Contrato duro
+
+- Auditar o target informado, não o repo inteiro por padrão.
+- Diagnóstico factual vem antes de proposta de correção.
+- Todo achado precisa de evidência concreta `arquivo:linha`.
+- Não criar finding por preferência genérica sem evidência local.
+- Regras locais reais prevalecem sobre boas práticas genéricas.
+- Não migrar lógica especialista de Flutter/Dart para o core universal.
+- Adapters por stack/backend são opcionais; fallback universal deve funcionar.
+- Não inventar comandos de validação: usar apenas manifests/configs/scripts reais.
+- `--handoff` gera artefato de plano em `.atlas/plans/`, mas não chama executor.
+
+## Fluxo obrigatório
+
+1. **Resolver boundary**
+   - Identificar `project_root`, `target`, paths reais e exclusões óbvias (`node_modules`, `build`, `dist`, `.git`, caches).
+   - Se `--scope` existir, tratar como recorte adicional, não expansão automática para repo inteiro.
+   - Registrar limitações se parte do target estiver ausente, gerada ou ilegível.
+
+2. **Ler regras locais reais**
+   - Procurar e consultar, quando existirem e forem relevantes ao boundary: `AGENTS.md`, `CLAUDE.md`, `README.md`, docs de rules, `project-rules/`, configs de lint/format/typecheck/test, manifests e arquivos de workspace.
+   - Não copiar regras integralmente no relatório; listar só fontes consultadas e regras aplicáveis.
+
+3. **Detectar stack/perfis**
+   - Usar `../_shared/references/stack-profiles.md` como baseline.
+   - Detectar por manifests/configs/comandos reais, não só por extensão.
+   - Perfis esperados quando houver sinal: Dart/Flutter, TypeScript/Node, Python, Go, Rust, Java/Kotlin, Firebase, Supabase, REST/OpenAPI.
+   - Se múltiplos perfis coexistirem, aplicar cada regra só ao boundary onde o sinal foi ativado.
+
+4. **Entender arquitetura antes de julgar**
+   - Mapear camadas reais, fluxo de dados, contratos, entrypoints, DI, estado, side effects, testes e consumidores afetados.
+   - Comparar com padrões existentes do repo antes de classificar algo como violação.
+
+5. **Auditar por lentes**
+   - Arquitetura e ownership.
+   - Contrato/dados/schemas/mappers/DTOs.
+   - Erros, falhas parciais, retries, cleanup.
+   - Segurança, authz/authn, segredos, trust boundaries.
+   - Estado, concorrência, lifecycle, idempotência.
+   - Fluxos previstos e imprevistos.
+   - Testes e validação declarada.
+   - Observabilidade, logs e diagnóstico.
+   - Manutenção/DX.
+
+6. **Ponytail pass final**
+   - Procurar abstração inútil, wrapper sem valor, código morto, duplicação simples, dependência excessiva, branching/config acidental e complexidade que não protege segurança/contrato/dados.
+   - Só registrar se houver simplificação clara e segura, com evidência local.
+
+## Severidade
+
+- `P0`: quebra crítica, perda/corrupção de dados, bypass de segurança, execução impossível.
+- `P1`: bug provável em fluxo principal, contrato errado, regressão relevante, risco alto.
+- `P2`: gap importante, cenário não coberto, arquitetura frágil, teste/validação faltante com risco real.
+- `P3`: melhoria localizada, simplificação Ponytail, DX/manutenção, observação de baixo risco.
+
+## Formato do achado
+
+```md
+### AUDIT-001 — P1 — <categoria>
+- Arquivo: `path/to/file.ext:123`
+- Evidência: <fato observado no código>
+- Impacto: <falha/risco concreto>
+- Correção proposta: <direção, sem implementar>
+- Dependências/bloqueios: <se houver>
+- Status: `open`
+```
+
+Se não houver linha precisa, não promova a finding; registre em limitações ou perguntas.
+
+## Relatório de auditoria
+
+Responder em pt-BR com:
+
+```md
+# Auditoria Atlas — <target>
+
+## Stack detectada
+...
+
+## Regras locais consultadas
+...
+
+## Boundary auditado
+...
+
+## Achados
+### P0
+...
+### P1
+...
+### P2
+...
+### P3
+...
+
+## Gaps por área
+- Contrato/dados:
+- Segurança:
+- Testes:
+- Arquitetura:
+
+## Limitações
+...
+
+## Próximo passo seguro
+...
+```
+
+Se zero achados, diga explicitamente `Nenhum achado P0/P1/P2/P3 com evidência suficiente no boundary auditado` e liste risco residual/limitações.
+
+## `--handoff`
+
+Quando `--handoff` estiver presente, escrever em `.atlas/plans/PLAN_AUDIT_<slug>.md` um plano **conforme ao `PLAN_TEMPLATE.md` canônico** (resolver em `<raiz-do-plugin>/packages/templates/`), para que passe no gate TC (`atlas_verify_template_conformance`) e seja consumível por `/workflow execute plan <path>` ou por `atlas-plan-execute`. O plano só pode conter tasks derivadas dos achados evidenciados. Se a escrita falhar, reportar bloqueio e não fingir que há handoff executável.
+
+A auditoria **não tem PRD**: a fonte de verdade é o relatório de auditoria + achados + regras locais reais. O plano espelha o template, mas reancorado na auditoria — **sem inventar decisões `D*` nem referências PRD inexistentes**.
+
+### Cabeçalho obrigatório (gate TC)
+
+O gate TC exige literalmente a linha `| **PRD** |`, referência a `BOUNDARY_PRD_PLAN.md` e tarefas `#### T01.`. Em `execution_mode: sequencial`, a §7 Slices é dispensável.
+
+```md
+# PLAN AUDIT — <target> (correção de auditoria)
+
+| Campo | Valor |
+|-------|-------|
+| **PRD** | N/A — origem auditoria; ver **Source audit** abaixo |
+| **Package / app** | `<boundary auditado>` |
+| **Tipo** | `audit-fix` |
+| **execution_mode** | `sequencial (T01→TN)` |
+| **Data** | <YYYY-MM-DD> |
+
+**Escopo técnico:** boundary da auditoria. **Fora:** <o que ficou fora do target/scope>.
+
+Política: [BOUNDARY_PRD_PLAN.md](./BOUNDARY_PRD_PLAN.md).
+
+## Metadados de execução
+- Plan prefix: `atlas`
+- Execution mode: `sequencial (T01→TN)`
+- Executor skill: `atlas-plan-execute`
+- Internal validator: `atlas-task-validator`
+- Source audit: `<título/path/data do relatório>`
+```
+
+> `N/A — origem auditoria` satisfaz o regex do TC declarando a proveniência sem inventar PRD.
+
+### Seções obrigatórias (§1–§6, §8)
+
+Sem PRD, as âncoras "derivados do PRD" do template passam a apontar para achados/regras locais:
+
+- **§1 Tradução executiva** — 1 parágrafo do que será corrigido + resultado observável; referência ao relatório de auditoria.
+- **§2 Invariantes de execução** — invariantes derivados das regras locais reais e do boundary (não de `D*`).
+- **§3 Pitfalls** — anti-padrões evidenciados na auditoria → correção canônica.
+- **§4 Estado na abertura da sprint** — 3–6 bullets do que está quebrado hoje, ancorados nos achados.
+- **§5 Tarefas de execução** — `#### T01.`…`#### TNN.`, uma por achado evidenciado (schema abaixo).
+- **§6 Contratos técnicos** — só se a auditoria revelou contrato/dados/schema afetado; senão `Não aplicável`.
+- **§8 Validação e checklist (validator)** — comandos reais detectados (manifests/scripts) + checkboxes derivados dos achados. Nunca inventar `flutter`/`npm`/`pytest`.
+
+### Schema de cada task (§5)
+
+```md
+#### T01. <correção curta>
+- **Objetivo:** <resultado observável>
+- **Referência ao achado:** `AUDIT-NNN` — `arquivo:linha`
+- **Mudança esperada:** <o que muda concretamente>
+- **Invariantes preservados:** <§2 / regra local>
+- **Não mudar:** <…>
+- **Dependências:** <nenhuma | T0X>
+- **Riscos:** <se relevante>
+- **Critério de done:** <sinal objetivo>
+- **Validação local:**
+  ```bash
+  cd <package> && <comando real>
+  ```
+```
+
+### Regras do handoff
+
+- Incluir apenas validações derivadas de manifests/configs reais.
+- Não usar task vaga como "refatorar geral".
+- Não incluir achado sem `arquivo:linha`; toda task aponta para um `AUDIT-NNN`.
+- Não chamar executor automaticamente.
+- Reportar o path final do plano e deixar claro que ele não foi executado.

package/plugins/atlas-workflow-orchestrator/packages/skills/atlas-audit/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "Atlas Audit"
+  short_description: "Auditoria universal sem correção de código"
+  default_prompt: "Use $atlas-audit para auditar o target informado contra regras locais, stack detectada e Ponytail pass, sem alterar código."
+
+policy:
+  allow_implicit_invocation: true

package/plugins/atlas-workflow-orchestrator/packages/skills/atlas-task-validator/SKILL.md

@@ -102,6 +102,12 @@ Ative regras específicas somente quando o perfil retornar `true`:
 - `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.
+- `go`: context/cancelamento, goroutines, erros retornados, data race e comandos Go declarados.
+- `rust`: `Result`/`Option`, ownership/lifetime, unwrap em fronteiras recuperáveis e comandos Cargo declarados.
+- `java_kotlin`: nullability, exceptions, resource cleanup, threads/coroutines e Maven/Gradle declarados.
+- `firebase`: rules/claims/authz, paths/ownership, listeners e emuladores/checks declarados.
+- `supabase`: RLS/auth claims, schema/migrations, RPC/Edge Functions, storage policies e checks declarados.
+- `rest_openapi`: request/response, status codes, paginação, erros, idempotência e contrato OpenAPI quando presente.
 
 Monorepo pode ativar múltiplos perfis, sempre restritos ao boundary correspondente. Fixture Node sem sinal Flutter não recebe regra Flutter/GetX.
 

package/plugins/atlas-workflow-orchestrator/skills/_shared/references/stack-profiles.md

@@ -33,4 +33,40 @@ Ativação é determinística: inspecione manifests no boundary e comandos realm
 - parsing/typing nas fronteiras e mutabilidade de defaults;
 - `pytest`, `ruff`, `mypy` ou equivalente apenas se declarados.
 
+## Go — `go.mod` ou comando Go real
+
+- context propagation/cancelamento, goroutine leak, data race e cleanup;
+- erros retornados sem swallow, wrapping útil e validação em fronteiras;
+- `go test`, `go vet`, `go test -race` e linters somente quando declarados/aplicáveis.
+
+## Rust — `Cargo.toml` ou comando Cargo real
+
+- ownership/lifetime usados para segurança real, não wrappers desnecessários;
+- `Result`/`Option` tratados sem `unwrap`/`expect` em fronteiras recuperáveis;
+- `cargo test`, `cargo check`, `cargo clippy` e `cargo fmt` somente quando declarados/aplicáveis.
+
+## Java/Kotlin — Maven/Gradle ou comando Java/Kotlin real
+
+- nullability, exceptions, resource cleanup e lifecycle de threads/coroutines;
+- boundaries de DTO/entity, serialização e validação de input;
+- `mvn test`, `gradle test`, linters/typecheck somente quando declarados.
+
+## Firebase — `firebase.json`, `.firebaserc` ou dependência Firebase real
+
+- regras/claims/authz, paths e ownership de dados;
+- falhas offline/retry, listeners/subscriptions e cleanup;
+- emuladores/deploy/checks somente quando declarados.
+
+## Supabase — dependência Supabase real
+
+- RLS/auth claims, schema/migrations, RPC/Edge Functions e storage policies;
+- sessão/token refresh, SSR/cookies quando aplicável e boundaries de dados;
+- CLI/migration/testes somente quando declarados.
+
+## REST/OpenAPI — OpenAPI/Swagger ou servidor/cliente HTTP real
+
+- compatibilidade request/response, status codes, paginação, erros e idempotência;
+- validação runtime nas bordas e divergência entre contrato e implementação;
+- geração/validação OpenAPI somente quando declarada.
+
 Perfis podem coexistir em monorepo. Regra de perfil nunca vira finding fora do boundary onde seu sinal foi ativado.

package/plugins/atlas-workflow-orchestrator/skills/_shared/scripts/document_quality.mjs

@@ -10,7 +10,11 @@ const VALID = Object.freeze({
   state: new Set(['backlog', 'ready', 'doing', 'review', 'done', 'blocked']),
 });
 
-const STACK_MANIFESTS = ['package.json', 'tsconfig.json', 'pubspec.yaml', 'pyproject.toml', 'requirements.txt', 'setup.py'];
+const STACK_MANIFESTS = [
+  'package.json', 'tsconfig.json', 'pubspec.yaml', 'pyproject.toml', 'requirements.txt', 'setup.py',
+  'go.mod', 'Cargo.toml', 'pom.xml', 'build.gradle', 'build.gradle.kts', 'settings.gradle', 'settings.gradle.kts',
+  'firebase.json', '.firebaserc', 'openapi.yaml', 'openapi.yml', 'openapi.json', 'swagger.yaml', 'swagger.yml', 'swagger.json',
+];
 
 function boundaryRoot(projectRoot, boundary) {
   const project = path.resolve(projectRoot);
@@ -47,6 +51,9 @@ function containsGetxImport(root) {
 
 function detectBoundaryProfile(root, declaredCommands) {
   const exists = (name) => fs.existsSync(path.join(root, name));
+  const readIfExists = (name) => {
+    try { return exists(name) ? fs.readFileSync(path.join(root, name), 'utf8') : ''; } catch { return ''; }
+  };
   const commands = declaredCommands.filter((v) => typeof v === 'string');
   let packageJson = null;
   if (exists('package.json')) {
@@ -57,13 +64,36 @@ function detectBoundaryProfile(root, declaredCommands) {
     try { pubspec = fs.readFileSync(path.join(root, 'pubspec.yaml'), 'utf8'); } catch {}
   }
   const packageCommands = Object.values(packageJson?.scripts ?? {}).filter((v) => typeof v === 'string');
+  const packageDeps = Object.keys({
+    ...(packageJson?.dependencies ?? {}),
+    ...(packageJson?.devDependencies ?? {}),
+    ...(packageJson?.peerDependencies ?? {}),
+    ...(packageJson?.optionalDependencies ?? {}),
+  });
+  const cargo = readIfExists('Cargo.toml');
+  const pom = readIfExists('pom.xml');
+  const gradle = `${readIfExists('build.gradle')}\n${readIfExists('build.gradle.kts')}\n${readIfExists('settings.gradle')}\n${readIfExists('settings.gradle.kts')}`;
   const allCommands = [...commands, ...packageCommands];
   const hasCommand = (re) => allCommands.some((command) => re.test(command));
+  const hasPackageDep = (re) => packageDeps.some((dep) => re.test(dep));
+  const javaKotlinSignal = exists('pom.xml') || exists('build.gradle') || exists('build.gradle.kts')
+    || exists('settings.gradle') || exists('settings.gradle.kts') || hasCommand(/\b(gradle|mvn|java|javac|kotlinc)\b/);
+  const restSignal = exists('openapi.yaml') || exists('openapi.yml') || exists('openapi.json')
+    || exists('swagger.yaml') || exists('swagger.yml') || exists('swagger.json')
+    || hasPackageDep(/\b(openapi|swagger|express|fastify|koa|hono|axios|ky)\b/i)
+    || /openapi|swagger|spring-boot-starter-web|ktor|retrofit/i.test(`${pom}\n${gradle}\n${pubspec}`);
   return {
     universal: true,
     flutter_dart: exists('pubspec.yaml') || hasCommand(/\b(flutter|dart)\b/),
     node_typescript: exists('package.json') || exists('tsconfig.json') || hasCommand(/\b(node|npm|pnpm|yarn|bun|tsc)\b/),
     python: exists('pyproject.toml') || exists('requirements.txt') || exists('setup.py') || hasCommand(/\b(python3?|pytest|ruff|mypy)\b/),
+    go: exists('go.mod') || hasCommand(/\bgo\s+(test|build|run|vet|fmt)\b/),
+    rust: exists('Cargo.toml') || hasCommand(/\bcargo\s+(test|build|run|check|clippy|fmt)\b/) || /^\s*\[package\]/m.test(cargo),
+    java_kotlin: javaKotlinSignal,
+    firebase: exists('firebase.json') || exists('.firebaserc') || hasPackageDep(/^firebase$|^@firebase\/|firebase-admin/i)
+      || /firebase_core|cloud_firestore|firebase_auth|firebase_messaging|firebase_storage/i.test(pubspec),
+    supabase: hasPackageDep(/^@supabase\/|supabase-js/i) || /supabase_flutter|supabase|postgrest/i.test(pubspec),
+    rest_openapi: restSignal,
     getx: /^\s{0,4}get\s*:/m.test(pubspec) || containsGetxImport(root),
   };
 }
@@ -80,6 +110,12 @@ export function detectStackProfiles(root, declaredCommands = [], boundaryPaths =
     flutter_dart: boundaries.some((profile) => profile.flutter_dart),
     node_typescript: boundaries.some((profile) => profile.node_typescript),
     python: boundaries.some((profile) => profile.python),
+    go: boundaries.some((profile) => profile.go),
+    rust: boundaries.some((profile) => profile.rust),
+    java_kotlin: boundaries.some((profile) => profile.java_kotlin),
+    firebase: boundaries.some((profile) => profile.firebase),
+    supabase: boundaries.some((profile) => profile.supabase),
+    rest_openapi: boundaries.some((profile) => profile.rest_openapi),
     getx: boundaries.some((profile) => profile.getx),
     boundaries,
   };