izanagi-ai 2.10.2 → 2.10.4

package/.manifest

@@ -1,11 +1,11 @@
 {
   "name": "izanagi-ai",
-  "version": "2.10.2",
+  "version": "2.10.4",
   "description": "Izanagi AI - Modular Skill-Oriented AI Prompt & Agent Framework for Autonomous Software Engineering",
   "author": "Pedro Henrique Sanches Leal",
   "license": "MIT",
   "homepage": "https://github.com/pedrohenriquesanchesleal4-debug/izanagi-ai#readme",
-  "generatedAt": "2026-08-12T12:41:40.251Z",
+  "generatedAt": "2026-08-13T19:04:27.823Z",
   "agents": [
     {
       "id": "adversarial-critic",

package/AGENTS.md

@@ -1,6 +1,6 @@
 # AGENTS.md — Izanagi AI Framework Reference
 
-> Version 2.8.0
+> Version 2.10.3
 > Modular Skill-Oriented AI Prompt & Agent Framework for Autonomous Software Engineering
 > Multi-CLI: Opencode · Claude Code · Codex · Cursor · Copilot · Kimi (Smart Auto-Detection & Selective Generation)
 
@@ -8,19 +8,19 @@
 
 ## 1. Visão Geral do Framework
 
-Izanagi AI é um **framework meta** para engenharia de software autônoma orientada a agentes: arquitetura em camadas (Routing → Orchestration → Evaluation → Healing → Memory), biblioteca de skills especializadas, **Skill Composer** (15 composições de skills encadeadas por domínio), **21 agentes especializados**, **Memória Persistente Anti-Repetição** (`.agents/memoria/`), **Curadoria de Referências** (`references/`), **Checkpoint & Self-Healing Swarm Engine**, e uma **CLI executável (`izanagi`)** publicada no npm (`izanagi-ai`). Este repositório É o framework (não um app que o usa).
+Izanagi AI é um **framework meta** para engenharia de software autônoma orientada a agentes: arquitetura em camadas (Routing → Orchestration → Evaluation → Healing → Memory), biblioteca de skills especializadas, **Skill Composer** (15 composições de skills encadeadas por domínio), **21 agentes especializados core + gerados**, **Memória Persistente Anti-Repetição** (`.agents/memoria/`), **Curadoria de Referências** (`references/`), **Checkpoint & Self-Healing Swarm Engine**, e uma **CLI executável (`izanagi`)** publicada no npm (`izanagi-ai`). Este repositório É o framework (não um app que o usa).
 
 ---
 
-## 2. Os 18 Agentes & Comandos Opencode (`/`)
+## 2. Os 21 Agentes Especializados & Comandos Opencode (`/`)
 
-O framework conta com **21 agentes especializados** em `agents/*.json` + orquestrador `/agents` (`.opencode/agent/agents.md`). Por padrão, tarefas complexas ativam o **Multi-Agent Swarm Mode** (execução paralela concorrente de múltiplos especialistas).
+O framework conta com **21 agentes especializados** em `agents/*.json` + orquestrador `/agents` (`.opencode/agent/agents.md`). Tarefas complexas ativam o **Multi-Agent Swarm Mode** (execução paralela concorrente de múltiplos especialistas com isolamento de contexto).
 
 | Comando | Arquivo | Papel & Especialidade |
 |---|---|---|
 | `/agents` | `.opencode/agent/agents.md` | Orquestrador Multi-Agente (Swarm Mode padrão / Paralelo) |
 | `/discovery` | `agents/discovery-agent.json` | Pré-produção: entrevista condicional, pesquisa web, preview, prompt rico ⭐ |
-| `/product-reasoner` | `agents/product-reasoner-agent.json` | Entendimento: requisitos com evidências (FACT/ASSUMPTION/UNKNOWN), critérios BDD 🆕 |
+| `/product-reasoner` | `agents/product-reasoner-agent.json` | Entendimento: requisitos com evidências (FACT/ASSUMPTION/UNKNOWN), critérios BDD |
 | `/animation` | `agents/animation-agent.json` | Scrollytelling, 3D WebGL, motion signature |
 | `/architect` | `agents/architect-agent.json` | System design, Clean Arch, DDD, CQRS, ADRs |
 | `/senior-engineer` | `agents/senior-engineer-agent.json` | Full-stack dev, refactoring, código limpo/testável |
@@ -29,7 +29,7 @@ O framework conta com **21 agentes especializados** em `agents/*.json` + orquest
 | `/security` | `agents/security-agent.json` | OWASP Top 10, auth, secure coding |
 | `/devops` | `agents/devops-agent.json` | CI/CD, Docker, K8s, IaC, observabilidade |
 | `/database` | `agents/database-agent.json` | SQL, PostgreSQL, Redis, modelagem de dados |
-| `/qa` | `agents/qa-agent.json` | QA & Test Automation: unitários, integração, E2E (Playwright), acessibilidade (WCAG) 🆕 |
+| `/qa` | `agents/qa-agent.json` | QA & Test Automation: unitários, integração, E2E (Playwright), acessibilidade (WCAG) |
 | `/bug-hunter` | `agents/bug-hunter-agent.json` | Debug, root cause analysis |
 | `/docs` | `agents/docs-agent.json` | Docs técnicos, READMEs, diagramas |
 | `/pm` | `agents/pm-agent.json` | Sprints, milestones, riscos |
@@ -38,16 +38,18 @@ O framework conta com **21 agentes especializados** em `agents/*.json` + orquest
 | `/evaluator` | `agents/evaluator-agent.json` | Critério técnico, avaliação objetiva de entregas |
 | `/adversarial-critic` | `agents/adversarial-critic-agent.json` | Crítica destrutiva-construtiva, pontos cegos |
 | `/form-engineer` | `agents/form-engineer-agent.json` | Formulários high-craft: validação, wizard, acessibilidade |
-| `/agent-architect` | `agents/agent-architect-agent.json` | Projeta novos agentes (Genome, guardrails, avaliação) por lacuna real 🆕 |
-| `/skill-architect` | `agents/skill-architect-agent.json` | Curadoria de skills: security scan, anti-duplicação, lacunas comprovadas 🆕 |
+| `/agent-architect` | `agents/agent-architect-agent.json` | Projeta novos agentes (Genome, guardrails, avaliação) por lacuna real |
+| `/skill-architect` | `agents/skill-architect-agent.json` | Curadoria de skills: security scan, anti-duplicação, lacunas comprovadas |
+| *Dinâmico* | `agents/generated/c-systems-engineer.json` | Engenharia C & Baixo Nível: gestão de memória, ponteiros, GCC/CMake, Valgrind |
 
 ---
 
 ## 3. Comandos de Desenvolvimento (ordem importa)
 
 ```
-npm install          # instala deps (self-dependency: package.json depende de "izanagi-ai")
+npm install          # instala deps
 npm run build        # tsc && node dist/scripts/generate-manifest.js
+npm test             # build + node --test dist/runtime/tests/*.test.js (165 testes)
 npm run verify       # build + teste de instalação em sandbox (passa todos os pack IDs)
 npm run doctor       # node bin/izanagi.js doctor — auditoria de integridade
 npm run bump:patch   # npm version patch --no-git-tag-version (também minor/major)
@@ -57,27 +59,29 @@ npm publish          # prepublishOnly roda build; depois: git push
 **Gotchas críticos:**
 - `dist/` é gitignored e `bin/izanagi.js` importa de `../dist/cli/index.js` — **rode `npm run build` antes de qualquer comando CLI local**, senão roda código obsoleto ou quebra.
 - `doctor` valida: SYSTEM.md/RULES.md, JSONs de agentes e aliases do resolver → targets.
-- Não há test runner (sem `npm test`). Verificação = `npm run build` + `npm run verify` + `npm run doctor`.
+- Há test runner real (`node:test`, 165 testes em `src/runtime/tests/`). Verificação = `npm test` + `npm run verify` + `npm run doctor`.
 - Padrão de commit do repo: `chore: bump to vX.Y.Z` para bumps e `feat:`/`fix:`/`docs:` descritivos em PT-BR para mudanças.
 
 ---
 
 ## 4. Estrutura do Framework
 
-- `core/` — 10 engines (.md, incluindo `skill-composer.md` e `checkpoint-healing-engine.md`) + **`skill-resolver.json`** (mapa alias → target + seção `compositions`)
-- `agents/` — 21 definições de agentes em JSON (fonte da verdade para os comandos) com `chains` compostas e Agent Genome (13 campos)
+- `core/` — 10+ engines (.md, incluindo `skill-composer.md`, `checkpoint-healing-engine.md`, `quality-gates.md`) + **`skill-resolver.json`** (mapa alias → target + seção `compositions`)
+- `agents/` — Definições de agentes em JSON (fonte da verdade para os comandos) com `chains` compostas e Agent Genome (13 campos)
 - `skills/` — 212 skills em `skills/<name>/SKILL.md` (+ `references.md` opcional), incluindo `design-directions` (Style Selector por indústria), `ui-ux-pro-max` (design system com motor BM25 offline em Node) e `anti-ai-slop` (auditoria zero "cara de IA")
 - `references/` — curadoria de referências reais por domínio (webgl-3d, scrollytelling, ui-design-systems, stack-2026, performance-seo)
 - `.agents/memoria/` — memória persistente anti-repetição: `contexto.md`, `decisoes.md`, `erros-corrigidos.md`, `learnings.md`
-- `.opencode/agent/` — comandos slash do Opencode; adapters equivalentes gerados sob demanda em `.claude/`, `.codex/`, `.cursor/`, `.github/`, `.kimi/`
+- `.opencode/agent/` — comandos slash do Opencode; adapters gerados sob demanda em `.claude/`, `.codex/`, `.cursor/`, `.github/`, `.kimi/`
 - `src/` — CLI TypeScript (entrypoint: `src/cli/index.ts` → `runCLI`; multi-CLI export: `src/exporters.ts`)
-- `SYSTEM.md` & `RULES.md` — fundação e regras operacionais (Anti-Generic High-Craft & Cinematic UI)
+- `SYSTEM.md` & `RULES.md` — fundação e regras operacionais (Anti-Generic High-Craft, Masterpiece Gate & Cinematic UI)
 
 ---
 
-## 5. Regras de Execução & Autonomia
+## 5. Regras de Execução, Autonomia & Masterpiece Gate
 
-- **Estudo Antes de Codar (Study-First):** toda tarefa começa (1) carregando `.agents/memoria/` (aprendizados, erros já corrigidos, decisões — nunca repita um erro já resolvido), (2) consultando `references/` e/ou `deep-research` quando a tarefa exigir informação externa, e só então (3) arquitetar e implementar. Nunca programe no escuro.
+- **Estudo Antes de Codar (Study-First):** toda tarefa começa (1) carregando `.agents/memoria/`, (2) consultando `references/` e/ou `deep-research` quando a tarefa exigir informação externa, e só então (3) arquitetar e implementar. Nunca programe no escuro.
+- **Lei da Fidelidade Absoluta a Referências (Anti-Rush):** Quando solicitado clonagem, inspiração ou replicação de uma referência visual/técnica (ex: `igloo.inc`), os agentes têm **estritamente proibido** retornar respostas apressadas ou fingir estudo superficial. É obrigatório decompor rigorosamente a estrutura, tipografia, grid, animações e micro-interações da referência e entregar uma obra de excelência artesanal (*High-Craft*) idêntica ou superior.
+- **Zero Falsificação de Pesquisa (Anti-Fake-Research):** Nunca afirme ter estudado ou analisado um site ou documento sem processá-lo com profundidade real. Cada entrega reflete estudo genuíno e maestria técnica.
 - **Composição de Skills Obrigatória:** skills nunca são usadas isoladas. O `core/skill-composer.md` + `compositions` do `skill-resolver.json` definem cadeias encadeadas por domínio.
 - **Execução Paralela Concorrente:** Ative múltiplos agentes especializados simultaneamente para frentes distintas.
 - **Pré-instalação de Dependências:** Baixe e instale pacotes necessários (`npm install`) **antes** de criar ou alterar arquivos de código. Nunca espere o usuário fazer.
@@ -85,7 +89,7 @@ npm publish          # prepublishOnly roda build; depois: git push
 - **Lei da Entrega Exaustiva e Profunda (Anti-Stub / Anti-Lazy-Code):** Em QUALQUER solicitação (feature, componente, tela ou script), é **estritamente proibido** escrever código esparso, stubs vazios (`TODO`, `// implement later`) ou arquivos mínimos. Toda entrega deve ser **profunda, rica, robusta e completa de primeira**, com tipagem estrita, estados reais, tratamento de erros e lógica funcional pronta para produção.
 - **Lei da Geração de Código Real e Zero Listas (Anti-Checklist / Anti-Summary):** É estritamente proibido responder a pedidos de sistemas, apps ou SaaS com listas de tarefas resumidas (`[✓] 1. Criar banco...`), resumos textuais ou stubs vagos. O Izanagi exige a **geração de código real, completo e produtivo** para cada arquivo necessário (Schema Prisma, Rotas de API, Componentes React/Next.js com Tailwind, Middlewares de Auth, README de execução). Cada arquivo deve vir com seu código fonte 100% implementado, sem atalhos.
 - **Discovery Condicional:** Se o prompt do usuário já estiver detalhado e estruturado, o `/discovery` aprova automaticamente e gera o blueprint/prompt rico de imediato, sem entrevistas desnecessárias. Se for vago, conduz a entrevista sugerindo temas personalizados ao nicho.
-- **Style Selector Obrigatório (Design Directions First):** Em todo pedido de site/app/landing, o framework apresenta 3-5 direções de design BESPOKE para o nicho (`design-directions`) — paleta exata, tipografia com personalidade, layout e motion signature — e o usuário escolhe antes de codar. Nunca template único.
+- **Style Selector Obrigatório (Design Directions First):** Em todo pedido de site/app/landing, apresente 3-5 direções de design BESPOKE para o nicho (`design-directions`) — paleta exata, tipografia com personalidade, layout e motion signature — e o usuário escolhe antes de codar. Nunca template único.
 - **Anti AI-Slop (Zero "Cara de IA"):** toda UI entregue passa pela auditoria `anti-ai-slop` (ZERO tells: Inter default, gradientes roxo, hero + 3 cards, rounded-2xl uniforme, copy "Build the future"). Substituir por escolhas intencionais: tipografia distinta, cor dominante + acento, layout assimétrico, motion em 1-2 momentos-chave.
 - **Token Economy Ativa por Padrão:** a skill `economia-tokens` vale para toda sessão — contexto mínimo, prompt caching (estático primeiro, dinâmico por último), sliding window, coordenar agentes por artefatos em disco (nunca passar payloads gigantes entre agentes) e zero releituras. Economia se aplica a contexto inútil, nunca ao entregável.
 

package/CHANGELOG.md

@@ -4,6 +4,35 @@
 
 ---
 
+## [Unreleased]
+
+### Added
+- **Policy Engine** (`src/runtime/security/policy.ts`): permissão contextual (ambiente dev/ci/produção, trust tier builtin/generated/community), distinta do Security Scanner (que só detecta conteúdo perigoso). Wired em `ToolRegistry.execute()`.
+- **Trust tiers no Skill Scanner**: `scanDirectory` infere builtin/generated/community pela origem e `decideByTrustTier()` aplica bloqueio escalonado (mesmo nível de risco pode ser permitido para builtin e bloqueado para community) — inspirado no modelo de tiers do Hermes Skills Hub.
+- **Checkpoint/Resume real** (`src/runtime/recovery/checkpoint.ts`): o Orchestrator salva o progresso a cada rodada de batches; `resumeRunId` retoma sem replanejar nem reexecutar nós já concluídos, restaurando budget/artefatos/modelo. `izanagi resume <run-id>`.
+- **Decision Journal** (`src/runtime/memory/decisions.ts`): decisão + alternativas realmente consideradas (com score) + razão + confiança, para model-routing e agent-routing. `izanagi explain <run-id>`.
+- **Artifact Registry** (`src/runtime/artifacts/registry.ts`): artefatos rastreáveis (produtor, hash, dependências, versão em retry/replan) — `consumers()`/`history()` respondem rastreabilidade sem reconstruir a partir do trace.
+- **Human-in-the-loop real**: novo `GraphNode.kind: 'approval'` pausa a execução (não é falha, não aciona self-healing) até decisão via `izanagi approve <run-id>` / `izanagi reject <run-id> --reason="..."`, retomando pelo mesmo mecanismo de checkpoint.
+- CLI: `izanagi resume`, `izanagi approve`, `izanagi reject`, `izanagi explain`.
+
+### Changed
+- **BREAKING (comportamento, não API):** `izanagi run` agora executa via Adaptive Runtime (graph + adaptive routing + evaluation + trace + self-healing + memory) **por padrão** — antes disso era necessário `--runtime`/`-r`, e sem essa flag o comando só imprimia um plano estático e gravava `izanagi-prompt.md`, sem de fato executar nada. Elimina o caminho paralelo entre "run estático" e "run --runtime". `--runtime`/`-r` continuam aceitas como no-op de compatibilidade.
+- Novo modo `izanagi run "..." --prompt-only` (`-p`) preserva o comportamento antigo de só compilar `izanagi-prompt.md` para colar em outra ferramenta de IA, sem executar nada.
+- `ModelRouter.route()` respeita `IZANAGI_MODEL` (override manual) e `ModelRouter.loadProjectProviders()` lê `.izanagi/izanagi.config.json → models` — extensibilidade de catálogo que já era documentada mas nunca implementada.
+- `MemoryStore` passa a rastrear performance por modelo (`recordModelRun`/`modelStats`/`historicalPerformance()`), preenchendo `RoutingContext.historicalPerformance`, que antes existia no tipo mas nunca era populado.
+
+### Fixed
+- `GraphNode.condition` e `BenchmarkValidator.check` eram avaliados via `new Function(...)` — execução de código arbitrário sobre dados que podem vir de `.agents/benchmarks/*.json` de terceiros. Substituído por um avaliador de expressão seguro (parser/AST próprio, sem `eval`).
+- `TraceStore.list()` tinha um comparador de sort inconsistente (nunca retornava 0), causando ordenação não-determinística de runs com o mesmo timestamp — corrigido com desempate por sequência monotônica.
+- Removida a duplicação de roteamento de modelo entre `Orchestrator` e `cli/commands/run.ts` — o producer da CLI agora consome `ctx.model`/`ctx.provider` do próprio Orchestrator em vez de rotear de novo e aplicar fallback manual.
+- `izanagi run`/`resolve` não era `await`ado no dispatcher da CLI (fire-and-forget em uma função async) — corrigido.
+- Removida autodependência de `izanagi-ai` no próprio `package.json`.
+
+### Removed
+- 5 agentes placeholder de teste comitados por engano em `agents/generated/`.
+
+---
+
 ## [2.10.0] — 2026-08-11
 
 ### Added

package/CLAUDE.md

@@ -1,6 +1,6 @@
-# Izanagi AI — Claude Code Integration
+# Izanagi AI — Claude Code Integration (v2.10.3)
 
-Este projeto usa o **Izanagi AI Framework** — framework meta para engenharia de software autônoma orientada a agentes: arquitetura em camadas, biblioteca de skills especializadas e 12 agentes pré-definidos.
+Este projeto usa o **Izanagi AI Framework** (v2.10.3) — framework meta para engenharia de software autônoma orientada a agentes: arquitetura em camadas, biblioteca de skills especializadas e 21 agentes especializados core + gerados.
 
 ## Fonte da verdade
 
@@ -8,81 +8,41 @@ Este projeto usa o **Izanagi AI Framework** — framework meta para engenharia d
 
 - `AGENTS.md` — referência canônica do framework
 - `SYSTEM.md` — fundação do sistema (engines, quality gates, memória)
-- `RULES.md` — regras operacionais
-
-## Agentes (comandos slash)
-
-Ative com `/` no Claude Code — os 12 comandos estão em `.claude/commands/`:
-
-- `/animation` — Diretor de Experiência Cinematográfica Web — scrollytelling, scroll-driven, 3D WebGL, motion design de alto craft. Nunca entrega site estático ou animação genérica.
-- `/architect` — Arquiteta sistemas com trade-offs explícitos, ADRs, planos de implementação e JIT de complexidade
-- `/bug-hunter` — Caça bugs sistêmicos — reproduz, isola, causa raiz, corrige com teste de regressão
-- `/database` — Modelagem rigorosa, SQL otimizado a partir do plano real, migrações seguras e reversíveis
-- `/devops` — Infraestrutura como código, deploy seguro e rápido, CI/CD, observabilidade e runbooks
-- `/discovery` — Investigador de Pré-Produção — entrevista em 3 fases (~15 perguntas, uma por vez), pesquisa referências REAIS em 2 trilhas (visual + técnica), arquiteta a solução (blueprint + ADR-lite) e entrega um prompt rico de implementação. Nunca escreve código: o HARD-GATE só cai por dispensa explícita do usuário.
-- `/docs` — Documentação técnica que as pessoas usam — README, APIs, arquitetura, guias e diagramas
-- `/pm` — Entrega de projetos — escopo, tarefas atômicas, riscos, milestones, comunicação enxuta
-- `/professor` — Ensino adaptativo e mentoria — conceito → porquê → exemplo → prática, sem deixar dúvida
-- `/security` — Audita, previne e corrige vulnerabilidades (OWASP Top 10, auth, secrets, LGPD) — com fix acionável
-- `/senior-engineer` — Full-stack de alto craft — código limpo, seguro, testado e entregue rápido (sem redundância)
-- `/techlead` — Liderança técnica — decisões de arquitetura, code review que ensina, desbloqueio e dívida técnica
-
-## Skills curadas
-
-13 skills disponíveis em `.claude/skills/<nome>/SKILL.md` (carregadas automaticamente quando relevantes):
-
-- `brainstorming` — Transforma uma ideia bruta em design/spec completo por entrevista dirigida em 3 fases (~15 perguntas, uma por vez) +…
-- `deep-research` — Pesquisa profunda em múltiplas fontes na web: gera plano de busca, executa múltiplas queries, coleta, sintetiza e…
-- `ui-ux-pro-max` — Design intelligence profissional para UI/UX: gera design system completo…
-- `motion-design` — Skill de Motion Design para Web — escolha e uso correto de bibliotecas de animação: GSAP (ScrollTrigger, SplitText),…
-- `animation-web` — Skill de Web Animation Cinematográfica — scrollytelling, scroll-driven animations, scroll image sequences…
-- `webgl-3d` — Skill de 3D na Web — Three.js, React Three Fiber, WebGL, shaders (GLSL), scroll-driven 3D, partículas, modelos GLTF e…
-- `frontend` — Skill de frontend para o Izanagi. Contém todos os design tokens do Tailwind CSS, padrões de design identificados nas…
-- `tdd` — Test-Driven Development com Iron Law: escreva o teste antes, veja falhar, código mínimo para passar, refatore. Use em…
-- `security-privacy` — Skill de Seguranca e Privacidade para o Izanagi. Aborda OWASP Top 10, LGPD/GDPR, seguranca de APIs, authentication,…
-- `qa` — Skill de Quality Assurance para o IzanagiAI. Contém checklist completo de qualidade de código, validações de…
-- `memoria-projeto` — Mantém memória persistente do projeto entre sessões, guardando decisões, padrões de código e erros já resolvidos,…
-- `economia-tokens` — Reduz o consumo de tokens em QUALQUER tarefa de código ou análise de arquivos. Use sempre, em toda tarefa — não é…
-- `handoff-sessao` — Grava um resumo curto do estado da tarefa em andamento para retomar na próxima sessão sem perder contexto e sem…
-
-## Regras essenciais
+- `RULES.md` — regras operacionais (incluindo Masterpiece Gate e Anti-Rush & Absolute Fidelity)
+
+## Agentes Especializados (21 Core + Gerados)
+
+Ative com `/` — os comandos do Swarm cobrem todos os domínios:
+- `/agents` — Orquestrador Multi-Agente (Swarm Mode paralelo)
+- `/discovery` — Investigador de Pré-Produção e prompt rico
+- `/product-reasoner` — Requisitos com evidências FACT/ASSUMPTION/UNKNOWN e critérios BDD
+- `/animation` — Diretor de Experiência Cinematográfica Web (Scrollytelling, WebGL)
+- `/architect` — Arquiteto de Sistemas (Clean Arch, DDD, CQRS, ADRs)
+- `/senior-engineer` — Full-Stack Engineer High-Craft com TDD estrito
+- `/c-systems-engineer` — Engenharia C & Baixo Nível (gestão de memória, ponteiros, GCC/CMake, Valgrind)
+- `/techlead` — Tech Lead (Code review pedagógico e governança)
+- `/automation-engineer` — Engenheiro de Automações Profissionais (APIs, Browser, ETL)
+- `/security` — Security Engineer (OWASP Top 10, Auth, SAST)
+- `/devops` — DevOps Engineer (Docker, K8s, CI/CD, IaC)
+- `/database` — Database Engineer (SQL, PostgreSQL, Redis, modelagem)
+- `/qa` — QA & Test Automation Engineer (Unitários, Integração, E2E Playwright, WCAG)
+- `/bug-hunter` — Debugging avançado & Root Cause Analysis
+- `/docs` — Technical Writer (READMEs, diagramas, documentação Diátaxis)
+- `/pm` — Project Manager (Sprints, milestones, análise de riscos)
+- `/professor` — Professor / Mentor (Ensino adaptativo)
+- `/researcher` — Pesquisa estruturada baseada em evidência
+- `/evaluator` — Critério técnico e avaliação objetiva de entregas
+- `/adversarial-critic` — Crítica destrutiva-construtiva e pontos cegos
+- `/form-engineer` — Engenharia de Formulários High-Craft (Zod + React Hook Form, Wizards)
+- `/agent-architect` & `/skill-architect` — Fábrica de Agentes e Skills sob demanda
+
+## Regras Inegociáveis & Masterpiece Gate
 
 - **Arquitetura antes de código.** Toda decisão passa por engines de qualidade.
 - **Anti-generic, alto craft.** Nunca entregue código/UI genérica "cara de IA" — estética Apple-like/Awwwards (`bg-zinc-950`, glassmorphism, bento grids, micro-interações).
+- **Anti-Rush & Absolute Fidelity to References (Lei da Fidelidade Absoluta a Referências):** Proibido respostas apressadas ou estudo superficial de referências (ex: `igloo.inc`). Exigida decompilação rigorosa de grid, tipografia, animações e micro-interações para entrega de excelência *High-Craft* autêntica.
 - **Execução paralela.** Ative múltiplos agentes especializados para frentes distintas.
-- **Baixo token, alto sinal.** Comprima respostas; nunca repita contexto.
-- **Auto-correção e ensino.** Reflita após cada tarefa; ensine de forma adaptativa.
-- **Segurança não é opcional.** Sem secrets no código, sem credenciais hardcoded.
-
-## Sempre (consolidado dos 12 agentes)
-
-- Storyboard por cenas com intenção narrativa — nunca animar por animar
-- Definir e manter a Assinatura de Movimento (easing/timing/tempo) consistente em todo o site
-- Tratar scroll como timeline scrub (ease: 'none' proporcional), não só gatilho one-shot
-- Só animar transform + opacity; 60fps é requisito de entrega
-- Respeitar prefers-reduced-motion e prover fallback sem JS/WebGL
-- Performance é orçamento: LCP < 2.5s, INP < 200ms, CLS < 0.1 (validar com Lighthouse)
-- Mobile: repensar pinning pesado e câmeras longas (matchMedia), nunca simplesmente encolher
-- Consultar referências antes: Apple, Red Bull storytelling, uiprompts, Trionn, Obys, Codrops case studies
-- Se a tarefa é visual: 1 tela fiel + 1 alternativa ousada (trade-off explícito)
-- Eficiência de execução: uma entrega por arquivo, sem re-gravurar arquivos, sem repetição no chat
-- Trade-offs explícitos em formato ADR (contexto → opção → trade → decisão)
-- Perguntar o que falta em requisitos (hipotecagens em vez de supor)
-
-## Nunca (consolidado dos 12 agentes)
-
-- Entregar site estático quando o pedido pedir animação
-- Usar WebGL para efeito que CSS 3D resolve (ou Scroll-Driven Animations CSS)
-- Animar sem propósito (mover porque pode)
-- Ignorar mobile, DPR cap, LCP, reduced motion
-- Copiar código de biblioteca sem checar a versão (ex: Anime.js v3 vs v4, GSAP 3.x APIs)
-- Entregar template genérico 'cara de IA' (gradiente + fade padrão sem design system)
-- Reler arquivos já lidos ou repetir conteúdo no chat (economia de tokens)
-- Codificar sem plano nem ADR
-- Arquitetura de moda (microserviço para tudo)
-- Otimizar prematuramente o que não é gargalo
-- Assumir requisitos completos
-- Fixar sem reproduzir
+- **Zero Stubs / Zero Lazy Code:** Toda entrega deve ser profunda, rica e funcional de primeira.
 
 ---
 Gerado pelo Izanagi AI em `C:\Users\pedro.leal\Documents\NexusAI` — `izanagi export --cli claude`

package/README.md

@@ -23,8 +23,8 @@ izanagi --version
 | Comando | Descrição |
 |---|---|
 | `izanagi init [dir] [--packs a,b,c]` | Cria projeto com `.agents/` e seleção de packs de skills. |
-| `izanagi run [agent] --task "<task>"` | Analisa a tarefa, seleciona o agente ideal e resolve a cadeia de skills (graph + eval + trace via `--runtime`). |
-| `izanagi agent create "<requisito>" [--name=slug] [--skills=a,b]` | Agent Factory: gera agente com genome completo em `agents/generated/` (detecta lacuna vs. 18 core). |
+| `izanagi run [agent] --task "<task>"` | Analisa a tarefa, seleciona o agente ideal e executa via Adaptive Runtime (graph + adaptive routing + evaluation + trace + self-healing + memory) — caminho único, sem modo estático paralelo. `--prompt-only` só compila `izanagi-prompt.md` para colar manualmente em outra ferramenta, sem executar nada. |
+| `izanagi agent create "<requisito>" [--name=slug] [--skills=a,b]` | Agent Factory: gera agente com genome completo em `agents/generated/` (detecta lacuna vs. 21 core). |
 | `izanagi agent list \| inspect <name>` | Lista/inspeta agentes (inclui `agents/generated/`) com genome. |
 | `izanagi skill create <nome> --gap="<descrição>" [--force]` | Skill Factory: cria skill com frontmatter, security scan pré-escrita e recusa de lacuna já coberta. |
 | `izanagi skill list \| search <q> \| inspect <name>` | Lista, busca e detalha skills. |
@@ -36,6 +36,11 @@ izanagi --version
 | `izanagi trace [run-id]` | Traces de execução (spans, healing, graph, avaliação). |
 | `izanagi memory inspect \| search <q>` | Estado da memória de execução e busca em `.agents/memoria/`. |
 | `izanagi doctor [--deep]` | Auditoria de integridade; `--deep` adiciona security scan das 212 skills. |
+| `izanagi diagnose` | Diagnóstico profundo do runtime (state, agent genome, contratos de artifact). |
+| `izanagi resume <run-id>` | Retoma execução interrompida (crash) ou pausada a partir do checkpoint — sem replanejar nem reexecutar nós concluídos. |
+| `izanagi approve <run-id> [node-id]` | Aprova uma ação de alto risco pausada (nó `kind: 'approval'`) e retoma. |
+| `izanagi reject <run-id> [node-id] [--reason]` | Rejeita a ação pausada (o nó falha com o motivo) e retoma — self-healing/abort seguem normalmente. |
+| `izanagi explain <run-id>` | Por que o Izanagi decidiu isso: decisões (Decision Journal) + self-healing + veredito, sem chain-of-thought. |
 | `izanagi export --cli <cli>` | Regenera adapters multi-CLI (claude, codex, cursor, copilot, kimi, all). |
 | `izanagi --version` | Exibe a versão da CLI. |
 
@@ -44,6 +49,9 @@ izanagi --version
 ```bash
 izanagi run "Criar uma landing page de um SaaS de analytics"
 izanagi run architect --task "Design a microservices architecture"
+izanagi run "Deploy em produção" --verbose   # pausa em nós de aprovação (human-in-the-loop)
+izanagi approve <run-id>                     # aprova e retoma
+izanagi explain <run-id>                     # por que o Izanagi decidiu o que decidiu
 izanagi agent create "Especialista em Laravel" --skills=php,api
 izanagi skill create rabbitmq-orchestrator --gap="Orquestração de mensageria RabbitMQ"
 izanagi workflow inspect fullstack

package/ROADMAP.md

@@ -57,12 +57,31 @@
 - [x] **Agent Architect** — projeto de novos agentes (Genome + guardrails + avaliação) por lacuna real
 - [x] **Skill Architect** — curadoria de skills com security scan e anti-duplicação por lacuna comprovada
 - [x] **Benchmarks externos** — `benchmarks/*.json` carregados pelo registry sem duplicar IDs embutidos
-- [ ] **Plugin System** — skills de terceiros com sandbox e cadeia de confiança (usa o security scanner como porta de entrada) 📋
+- [x] **Plugin System (base)** — trust tiers (builtin/generated/community) no Skill Scanner com bloqueio escalonado + Policy Engine para permissão contextual; ainda falta sandbox de execução isolada para skills de terceiros 🔧
 - [ ] **Skill Marketplace** — compartilhar e instalar skills 📋
 - [ ] **Izanagi API** — interface REST para interrogção do framework 💡
 - [ ] **Web UI** — editor visual de skills e monitor de execuções 📋
 - [ ] **Analytics Dashboard** — token usage, custo e evolução por execução 📋
 
+## Fase 5 — Runtime de Produção v2.11 ✅
+
+Auditoria completa do framework + consolidação arquitetural (unificação de caminhos de execução, eliminação de duplicações) + as primitives que faltavam para o runtime ser "production-grade" pelos critérios de mercado 2026 (checkpoint/resume, observabilidade de decisão, rastreabilidade de artefato, human-in-the-loop real).
+
+- [x] **`izanagi run` unificado** — Adaptive Runtime (graph + routing + evaluation + trace + healing + memória) é o único caminho de execução, por padrão; eliminado o modo estático paralelo que só imprimia um plano sem executar. `--prompt-only` preserva a geração de prompt para colar em outra ferramenta.
+- [x] **Safe Expression Evaluator** (`src/runtime/orchestration/safe-eval.ts`) — substitui `new Function()`/eval sobre `GraphNode.condition` e `BenchmarkValidator.check`, que podiam vir de dados de terceiros (benchmarks externos).
+- [x] **Model Router com histórico e extensibilidade real** — `historicalPerformance` (antes um campo morto) agora é preenchido via `MemoryStore.recordModelRun`; `IZANAGI_MODEL` (override manual) e `.izanagi/izanagi.config.json → models` (catálogo por projeto) implementados.
+- [x] **Policy Engine** (`src/runtime/security/policy.ts`) — permissão CONTEXTUAL (ambiente dev/ci/produção, trust tier), distinta do Security Scanner (detecção de conteúdo perigoso). Wired em `ToolRegistry`.
+- [x] **Trust tiers no Skill Scanner** — builtin/generated/community com bloqueio escalonado por origem.
+- [x] **Checkpoint/Resume real** (`src/runtime/recovery/checkpoint.ts`) — progresso salvo a cada rodada de batches; `izanagi resume <run-id>` continua sem replanejar nem reexecutar nós concluídos, restaurando budget/artefatos/modelo.
+- [x] **Decision Journal** (`src/runtime/memory/decisions.ts`) — decisão + alternativas realmente consideradas + razão + confiança, para model-routing e agent-routing.
+- [x] **Artifact Registry** (`src/runtime/artifacts/registry.ts`) — artefatos rastreáveis (produtor, hash, dependências, versão em retry/replan).
+- [x] **Human-in-the-loop real** — `GraphNode.kind: 'approval'` pausa a execução (não é falha) até `izanagi approve`/`izanagi reject`, retomando via checkpoint.
+- [x] **CLI**: `izanagi resume`, `izanagi approve`, `izanagi reject`, `izanagi explain`.
+- [x] **Skill Lifecycle** — `discovered → draft → validated → active → deprecated → archived`; skills geradas pela Factory nascem `draft` (nunca "Generate → Automatically trust").
+- [x] **`doctor`/`diagnose` sem duplicação** — checks compartilhados (`src/cli/checks.ts`) computados uma vez, cada comando decide o que exibir.
+- [x] **Confirmado**: as 102 skills em `skills/*/SKILL.md` são 100% compliant com o padrão aberto agentskills.io (frontmatter `name`+`description`) — portáveis para ~40 ferramentas de mercado (Cursor, Copilot, Codex, VS Code...) sem modificação.
+- [ ] **Consolidação dos packs de skills legados** (`architecture/`, `coding/`, `security/`... vs. `skills/`) — depreciação com apontamento para o equivalente novo, em andamento 🔧
+
 ---
 
 ## Critérios de aceite das próximas fases

package/RULES.md

@@ -24,6 +24,8 @@
 | 14 | **Dynamic Industry-Tailored Design System** | Ao criar sites ou interfaces, **nunca** aplique um template genérico ou glassmorfismo automático. Analise o nicho solicitado e apresente/aplique um sistema visual bespoke (ex: FinTech = dados densos, tipografia mono, verde financeiro; Luxury Fashion = tipografia serifada editorial, espaço em branco generoso, monocromático; AI Tech = dark OLED `bg-zinc-950`, linhas finas de laser cyan/emerald, micro-interações de precisão). O design deve respirar a identidade real da indústria. |
 | 15 | **Style Selector (Design Directions First)** | Em TODO pedido de site, landing, dashboard ou produto visual, apresente **3-5 direções de design BESPOKE e distintas** para o nicho (skill `design-directions`) — com paleta exata, tipografia com personalidade, layout signature e motion signature — e deixe o usuário ESCOLHER antes de qualquer código. Proibido pular para template único. Exceção: dispensa explícita ("escolhe por mim"). |
 | 16 | **Anti AI-Slop (Catálogo de Tells)** | Após implementar QUALQUER UI, rode a auditoria `anti-ai-slop`: ZERO ocorrências de tells que denunciam IA — Inter como fonte única; gradientes roxo→azul; hero centralizado + 3 feature cards idênticos; glassmorphism em tudo; border-radius uniforme (rounded-2xl); paleta default do Tailwind; sombras sutis em cards brancos sobre #f9fafb; copy genérica ("Build the future", "Elevate", "Unleash", "Seamless", "Cutting-edge"); badges "✨/🚀" decorativos; ausência de micro-interações. Substitua por escolhas intencionais: tipografia com personalidade, cor dominante + acento afiado, layout assimétrico, hierarquia agressiva, motion em 1-2 momentos-chave. |
+| 17 | **Anti-Rush & Absolute Fidelity to References** | Quando solicitado clonagem, inspiração ou replicação de um site/projeto de referência (ex: `igloo.inc`), os agentes têm **estritamente proibido** retornar respostas apressadas ou fingir estudo superficial. É obrigatório decompor rigorosamente a estrutura, tipografia, grid, animações e micro-interações da referência e entregar uma obra de excelência artesanal (*High-Scale / High-Craft*) idêntica ou superior. |
+| 18 | **Zero Falsificação de Pesquisa (Anti-Fake-Research)** | Nunca afirme ter estudado ou analisado um site ou documento sem processá-lo com profundidade real. Cada entrega reflete estudo genuíno e maestria técnica. |
 
 ---
 

package/SYSTEM.md

@@ -30,6 +30,8 @@ Every decision, every line of code, every interaction passes through a layered e
 13. **Style Selector (Design Directions First).** Em todo pedido de site/app/landing, apresente 3-5 direções de design BESPOKE para o nicho antes de codar (skill `design-directions`) e deixe o usuário escolher. Nunca template único.
 14. **Anti AI-Slop (Zero "Cara de IA").** Toda UI entregue passa pela auditoria `anti-ai-slop`: ZERO tells (Inter default, gradientes roxo, hero + 3 cards, rounded-2xl uniforme, copy "Build the future"). Escolhas intencionais: tipografia com personalidade, cor dominante + acento afiado, layout assimétrico, motion em 1-2 momentos-chave.
 15. **Token Economy Ativa por Padrão.** Contexto mínimo, prompt caching (estático primeiro), sliding window, coordenação por artefatos em disco, zero releituras. Economia em contexto inútil — nunca no entregável.
+16. **Anti-Rush & Absolute Fidelity to References (Lei da Fidelidade Absoluta a Referências).** Quando solicitado clonagem, inspiração ou replicação de uma referência visual/técnica (ex: `igloo.inc`), os agentes têm **estritamente proibido** retornar respostas apressadas ou fingir estudo superficial. É obrigatório decompor rigorosamente a estrutura, tipografia, grid, animações e micro-interações da referência e entregar uma obra de excelência artesanal (*High-Craft*) idêntica ou superior.
+17. **Zero Falsificação de Pesquisa (Anti-Fake-Research).** Nunca afirme ter estudado ou analisado um site ou documento sem processá-lo com profundidade real. Cada entrega reflete estudo genuíno e maestria técnica.
 
 ---
 
@@ -81,16 +83,21 @@ User Input / Comando CLI
 | **Agent Factory** (`factories/agent-factory.ts`) | Gera novos agentes com genome a partir de requisito: detecção de lacuna vs. 21 core, ID slug, skills requeridas/opcionais, validação e escrita em `agents/generated/`. |
 | **Skill Factory** (`factories/skill-factory.ts`) | Cria skills novas com frontmatter, security scan pré-escrita, recusa de lacuna já coberta e escrita em `skills/generated/<name>/SKILL.md`. |
 | **Tool Registry** (`tools/registry.ts`) | Tools builtin (fs.read, fs.write, fs.ls) com sandbox de zona (anti path-traversal), permissões least-privilege e fluxo discover → permission → validate → execute. |
-| **Model Router** (`routing/model-router.ts`) | Seleção de modelo (claude/gpt/opus...) por custo/latência/contexto com fallback e override por env. |
+| **Model Router** (`model/router.ts`) | Seleção de modelo (claude/gpt/opus...) por custo/latência/contexto com fallback e override por env. |
 | **Healing Engine** | `retry` (transitório), `skill_replacement` (artefato inválido), `fallback`, `abort` (limite de tentativas). |
 | **Failure Memory** (`memory/store.ts`) | `recordFailure` + `findRelevantFailures` por categoria: erros reais registrados são injetados como evidência em runs futuros (anti-repetição). |
 | **Memory Store** (`memory/store.ts`) | Stats por agente, learnings, histórico de runs (JSON em disco). |
 | **Trace Store** (`observability/tracer.ts`) | Traces de execução em JSONL com spans, load/close e retry de escrita. |
 | **Benchmarks** (`benchmarks/`) | 10 casos builtin (parse, scoring, scanner, genome, composer...) executáveis via `izanagi benchmark` + `compare` entre builds. |
-| **LLM Executor** (`llm/`) | Adapters reais OpenAI/Anthropic/OpenRouter com env key, timeout e propagação de erro HTTP. |
+| **LLM Executor** (`llm/`) | Adapters reais OpenAI/Anthropic/Google com env key, timeout e propagação de erro HTTP. |
 | **Evidence System** (`research/evidence.ts`) | Claims FACT/ASSUMPTION/INFERENCE/UNKNOWN com fonte, confiança e hierarquia de sourceType (official docs > source code > tests > package metadata > reliable tech > community); relatório de claims críticas. |
 | **Token Budget 2.0** (`token/budget.ts`) | Orçamento por fase (planning/execution/evaluation/recovery) com tetos, pesos por complexidade e abort de fase — retry consome a fase recovery, nunca o execution. |
-| **CLI** (`src/cli/`) | Entrypoint `bin/izanagi.js` → `runCLI` (doctor --deep, audit, resolve, export, init, agent create, skill create --gap, workflow, trace, eval, benchmark, memory, diagnose...). |
+| **Policy Engine** (`security/policy.ts`) | Permissão CONTEXTUAL (ambiente dev/ci/produção, trust tier builtin/generated/community) — distinto do Skill Scanner (que detecta conteúdo perigoso, não decide permissão). Wired em `ToolRegistry.execute()`. |
+| **Checkpoint Store** (`recovery/checkpoint.ts`) | Progresso salvo a cada rodada de batches (grafo, artefatos, budget, tentativas); `resumeRunId` retoma sem replanejar nem reexecutar nós concluídos. |
+| **Approval Store** (`recovery/approvals.ts`) | Human-in-the-loop real: nó `kind: 'approval'` pausa a execução até `izanagi approve`/`reject`, sem acionar self-healing. |
+| **Decision Journal** (`memory/decisions.ts`) | Decisão + alternativas REALMENTE consideradas (com score) + razão + confiança, para model-routing e agent-routing — base do `izanagi explain`. |
+| **Artifact Registry** (`artifacts/registry.ts`) | Artefatos rastreáveis: produtor (agent/skill/run/nó), hash, dependências e versão (retry/replan do mesmo nó gera nova versão, não duplicata). |
+| **CLI** (`src/cli/`) | Entrypoint `bin/izanagi.js` → `runCLI` (doctor --deep, resume, approve, reject, explain, resolve, export, init, agent create, skill create --gap, workflow, trace, eval, benchmark, memory, diagnose...). |
 
 ## Routing — Classificação por Categoria
 
@@ -169,6 +176,28 @@ O ciclo completo de execução — `Task → Understanding → Planning → Exec
 5. **Self-Healing & Classification** — healing classificado (retry para transitório, `skill_replacement` para artefato inválido, fallback de modelo, abort por limite); cada healing é registrado com stats por agente.
 6. **Memory & Evolution** — `recordFailure` + `findRelevantFailures` (memória de falhas por categoria), learnings e traces; a memória curada `.agents/memoria/` é atualizada ao fim do ciclo.
 
+Toda rodada de batches persiste um checkpoint (§ Checkpoint & Resume) e cada decisão de roteamento vai para o Decision Journal (§ Decision Journal & Explainability) — o pipeline não é só "executa e esquece": o estado intermediário e o motivo de cada escolha ficam rastreáveis.
+
+## Checkpoint & Resume
+
+`src/runtime/recovery/checkpoint.ts` persiste, a cada rodada de batches do Orchestrator, o grafo (status por nó), artefatos, budget gasto por fase, tentativas e tokens. `izanagi resume <run-id>` reconstrói a execução a partir daí — sem replanejar, sem reexecutar nós `succeeded`/`skipped`, reusando o modelo/provider originais. O checkpoint é apagado ao chegar a um veredito terminal (PASS ou FAIL); só sobrevive uma interrupção real (crash) ou uma pausa de aprovação humana.
+
+## Human-in-the-Loop
+
+`GraphNode.kind: 'approval'` pausa a execução (não é falha — não aciona self-healing) até uma decisão humana via `izanagi approve <run-id>` ou `izanagi reject <run-id> --reason="..."`. Decisões ficam no Approval Store (`recovery/approvals.ts`), por run + nó; aprovar retoma normalmente, rejeitar falha o nó com o motivo e segue o fluxo normal de healing/abort a partir daí.
+
+## Decision Journal & Explainability
+
+`src/runtime/memory/decisions.ts` registra cada decisão de roteamento (model-routing, agent-routing) com a opção escolhida, as alternativas REALMENTE consideradas (com score) e a confiança (derivada da distância entre a escolhida e a melhor concorrente). `izanagi explain <run-id>` junta o journal + o self-healing + o veredito do trace para responder "por que o Izanagi decidiu isso" — só metadados/razões estruturadas, nunca chain-of-thought.
+
+## Artifact Registry
+
+`src/runtime/artifacts/registry.ts` torna artefatos rastreáveis além do `Map` efêmero de `ExecuteCtx`: cada nó bem-sucedido vira um registro com produtor (agent/skill/run/nó), hash, dependências (artefatos upstream) e versão — retry/replan do mesmo nó gera nova versão, não uma duplicata perdida.
+
+## Policy Engine
+
+`src/runtime/security/policy.ts` responde "isso é permitido NESTE CONTEXTO?" — distinto do Skill Scanner, que responde "isso parece perigoso?". A mesma permissão pode ser negada em produção e liberada em desenvolvimento, ou negada para uma skill de trust tier `community` e liberada para `builtin`. Regras default: deploy de produção e operações destrutivas em produção exigem aprovação humana; `community` nunca recebe `fs:write`/`shell` por default. Wired em `ToolRegistry.execute()` — a permissão bruta (least-privilege) e a política contextual são camadas distintas, ambas aplicadas.
+
 ## Agent Factory & Skill Factory
 
 Novos agentes e skills são **gerados, não escritos à mão**:
@@ -182,7 +211,7 @@ Novos agentes e skills são **gerados, não escritos à mão**:
 
 ## Model Router
 
-`src/runtime/routing/model-router.ts` seleciona o modelo por custo/latência/contexto (claude/gpt/opus...), com fallback em cadeia e override por env (`IZANAGI_MODEL`). O token budget de cada agente é declarado no genome e respeitado pelo runtime.
+`src/runtime/model/router.ts` seleciona o modelo por custo/latência/contexto (claude/gpt/opus...), com fallback em cadeia e override por env (`IZANAGI_MODEL`). O token budget de cada agente é declarado no genome e respeitado pelo runtime.
 
 ## Tool Registry (Tools/MCP-ready)
 
@@ -190,7 +219,7 @@ Novos agentes e skills são **gerados, não escritos à mão**:
 
 ## Doctor
 
-`izanagi doctor` audita integridade (SYSTEM.md/RULES.md, JSONs de agentes, aliases do resolver → targets); `izanagi doctor --deep` adiciona a varredura de segurança das 212 skills com `DEFENSIVE_CONTEXT` (exemplos educativos de segurança não são falsos positivos).
+`izanagi doctor` audita integridade (SYSTEM.md/RULES.md, JSONs de agentes, aliases do resolver → targets); `izanagi doctor --deep` adiciona memória/traces/benchmarks, a varredura de segurança das skills com `DEFENSIVE_CONTEXT` (exemplos educativos de segurança não são falsos positivos), manifesto de skills e a distribuição de skill lifecycle. `izanagi diagnose` cobre o mesmo terreno de runtime com foco em investigação de execução (agent genome, contratos de artifact) — os checks são computados uma vez só (`src/cli/checks.ts`), sem duplicação entre os dois comandos.
 
 ## Versioning
 
@@ -207,11 +236,20 @@ Skills com `SKILL.md` declararam (quando aplicável) metadados no frontmatter:
 - `name`
 - `description` (usado no scoring/resolução)
 - `version`
+- `lifecycle` (discovered/draft/validated/active/deprecated/archived — default `active` quando ausente)
 - `compatibility` (versão mínima do framework)
 - `triggers`
 - `token_budget`
 
-O resolver **tolera** skills sem frontmatter (parse devolve `{}` e segue resolvendo pelo alias); metadados apenas aumentam a qualidade do scoring.
+O resolver **tolera** skills sem frontmatter (parse devolve `{}` e segue resolvendo pelo alias); metadados apenas aumentam a qualidade do scoring. **Só `name` e `description` são exigidos** — o mesmo mínimo do padrão aberto [agentskills.io](https://www.agensi.io/learn/skill-md-specification-open-standard), o que torna as skills do Izanagi portáveis para qualquer ferramenta compatível (Cursor, Copilot, Codex, VS Code...) sem modificação.
+
+### Skill Lifecycle
+
+```
+DISCOVERED → DRAFT → VALIDATED → ACTIVE → DEPRECATED → ARCHIVED
+```
+
+Skills curadas do framework nascem `active`. Skills geradas pela Skill Factory (`izanagi skill create`) nascem `draft` — passaram no security scan mas não têm histórico de uso real; promoção a `active` é uma decisão separada (nunca "Generate → Automatically trust"). `izanagi skill list`/`inspect` mostram o estado; `doctor --deep`/`diagnose` reportam a distribuição.
 
 ---
 

package/agents/INDEX.md

@@ -5,11 +5,12 @@
 
 ---
 
-## Available Agents (14 Specialized Agents)
+## Available Agents (21 Core Agents)
 
 | Agent | Command | Role | File |
 |-------|---------|------|------|
 | **Discovery** | `/discovery` | Pré-produção: entrevista condicional, pesquisa de referências, direções e prompt rico | `discovery-agent.json` |
+| **Product Reasoner** | `/product-reasoner` | Raciocínio de produto: intenção vaga → requisitos estruturados, critérios BDD e evidências | `product-reasoner-agent.json` |
 | **Animation Engineer** | `/animation` | Scrollytelling, WebGL 3D, motion signature, design cinematográfico | `animation-agent.json` |
 | **Software Architect** | `/architect` | System design, Clean Arch, Hexagonal, DDD, CQRS, ADRs | `architect-agent.json` |
 | **Senior Engineer** | `/senior-engineer` | Full-stack development, refactoring, código limpo e testável | `senior-engineer-agent.json` |
@@ -18,11 +19,20 @@
 | **Security Engineer** | `/security` | Mitigação OWASP Top 10, auth, secure coding e secrets | `security-agent.json` |
 | **DevOps Engineer** | `/devops` | Pipelines CI/CD, Docker, Kubernetes, IaC e observabilidade | `devops-agent.json` |
 | **Database Engineer** | `/database` | Modelagem de dados, otimização SQL, PostgreSQL, Redis | `database-agent.json` |
-| **QA & Test Automation Engineer** | `/qa` | Testes unitários, integração, E2E (Playwright), acessibilidade (WCAG), quality gates 🆕 | `qa-agent.json` |
+| **QA & Test Automation Engineer** | `/qa` | Testes unitários, integração, E2E (Playwright), acessibilidade (WCAG), quality gates | `qa-agent.json` |
 | **Bug Hunter** | `/bug-hunter` | Debugging sistemático e análise de causa raiz | `bug-hunter-agent.json` |
 | **Documentation Writer** | `/docs` | Documentação técnica, READMEs e diagramas UML | `docs-agent.json` |
 | **Project Manager** | `/pm` | Sprints, milestones, análise de riscos técnicos | `pm-agent.json` |
 | **Professor** | `/professor` | Ensino adaptativo, explicação didática e mentoria técnica | `professor-agent.json` |
+| **Researcher** | `/researcher` | Pesquisa estruturada baseada em evidência: FACT/ASSUMPTION/INFERENCE/UNKNOWN, fontes citadas | `researcher-agent.json` |
+| **Evaluator** | `/evaluator` | Avaliação estruturada de resultados: score por métricas, verdict, detecção de regressões | `evaluator-agent.json` |
+| **Adversarial Critic** | `/adversarial-critic` | Crítica destrutiva-construtiva: bugs, segurança, arquitetura, edge cases, overengineering | `adversarial-critic-agent.json` |
+| **Form & UI Engineer** | `/form-engineer` | Formulários High-Craft: Zod + React Hook Form, wizards, auto-save, WCAG 2.2 AA | `form-engineer-agent.json` |
+| **Agent Architect** | `/agent-architect` | Fábrica de agentes: Capability Analysis → Skill Discovery → Genome → Registration | `agent-architect-agent.json` |
+| **Skill Architect** | `/skill-architect` | Fábrica de skills: Capability Gap → Draft → Tests → Security Scan → Register | `skill-architect-agent.json` |
+
+Agentes core: 21 arquivos em `agents/*.json` (fonte de verdade, contagem derivada de `.manifest`).
+Agentes gerados sob demanda ficam em `agents/generated/` (ex.: `c-systems-engineer.json`, criado pela Agent Factory para uma lacuna real e mantido por ter uso ativo — ver `izanagi agent create`).
 
 ---