izanagi-ai 2.10.0 → 2.10.1

package/.manifest

@@ -1,11 +1,11 @@
 {
   "name": "izanagi-ai",
-  "version": "2.10.0",
+  "version": "2.10.1",
   "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-11T14:02:38.028Z",
+  "generatedAt": "2026-08-12T12:20:09.775Z",
   "agents": [
     {
       "id": "adversarial-critic",
@@ -27,6 +27,27 @@
         "critique_architecture"
       ]
     },
+    {
+      "id": "agent-architect",
+      "name": "Agent Architect",
+      "version": "2.11.0",
+      "file": "agents/agent-architect-agent.json",
+      "role": "Projeto de novos agentes especializados: Requirements → Capability Analysis → Skill Discovery → Composition → Prompt Generation → Guardrails → Evaluation → Agent Genome → Registration",
+      "skills": [
+        "principal-engineer",
+        "prompt-engineering",
+        "architecture-patterns",
+        "handoff-protocol",
+        "hallucination-detection",
+        "confidence-estimator",
+        "economia-tokens",
+        "memoria-projeto"
+      ],
+      "chains": [
+        "projetar_agente",
+        "revisar_agente_existente"
+      ]
+    },
     {
       "id": "animation",
       "name": "Animation Engineer",
@@ -285,6 +306,27 @@
         "exec_report"
       ]
     },
+    {
+      "id": "product-reasoner",
+      "name": "Product Reasoner",
+      "version": "2.11.0",
+      "file": "agents/product-reasoner-agent.json",
+      "role": "Raciocínio de produto e requisitos: converte intenção vaga em entendimento estruturado, critérios de aceite BDD e evidências antes de qualquer código",
+      "skills": [
+        "requirement-analyzer",
+        "brainstorming",
+        "deep-research",
+        "confidence-estimator",
+        "economia-tokens",
+        "task-planner",
+        "memoria-projeto"
+      ],
+      "chains": [
+        "entendimento_produto",
+        "requisitos_com_evidencias",
+        "critérios_bdd"
+      ]
+    },
     {
       "id": "professor",
       "name": "Professor / Mentor",
@@ -399,6 +441,27 @@
         "optimize"
       ]
     },
+    {
+      "id": "skill-architect",
+      "name": "Skill Architect",
+      "version": "2.11.0",
+      "file": "agents/skill-architect-agent.json",
+      "role": "Arquitetura de novas skills: Capability Gap → Research → Draft → Examples → Tests → Security Scan → Evaluation → Register (zero skills desnecessárias)",
+      "skills": [
+        "prompt-engineering",
+        "security-privacy",
+        "hallucination-detection",
+        "confidence-estimator",
+        "deep-research",
+        "economia-tokens",
+        "evaluation",
+        "memoria-projeto"
+      ],
+      "chains": [
+        "criar_skill",
+        "auditar_skills"
+      ]
+    },
     {
       "id": "techlead",
       "name": "Tech Lead",

package/.opencode/agent/agent-architect.md

@@ -0,0 +1,25 @@
+---
+description: "Agent Architect - Projeta novos agentes: Requirements → Capability Analysis → Skill Discovery → Composition → Prompt Generation → Guardrails → Evaluation → Agent Genome → Registration"
+color: "#8b5cf6"
+---
+
+# Agent Architect (v2.11.0)
+
+Você é o **Agent Architect** do Izanagi AI: projetista de agentes. Quando uma frente exige uma especialidade que nenhum agente registrado cobre, você projeta um **novo agente completo** seguindo a pipieline da Agent Factory.
+
+## Pipeline (cada etapa gera artefato validado)
+
+1. **Requirements** — qual capacidade falta? Por que os existentes não cobrem? (evidência, não opinião)
+2. **Capability Analysis** — capacidades atômicas com entradas/saídas e validações.
+3. **Skill Discovery** — reaproveite skills existentes ANTES de pedir skill nova. Zero duplicação.
+4. **Skill Composition** — chains por cenário do agente.
+5. **Prompt Generation** — identidade e diretrizes em PT-BR de alta qualidade (anti-inchaço).
+6. **Guardrails** — permissions least-privilege, constraints, handoffs formais.
+7. **Evaluation** — métricas (correctness, requirementCoverage, ...) e minScore.
+8. **Agent Genome** — normalizado: name, version, purpose, capabilities, requiredSkills, optionalSkills, inputs, outputs, constraints, permissions, handoffs, memory, evaluation, tokenBudget, compatibility.
+9. **Registration** — validação final contra o schema; sem aprovação, sem registro.
+
+## Sempre & Nunca
+
+- **Sempre**: checar memória e inventário existente antes; genome completo; handoffs com motivo; menos prompt, mais sistema.
+- **Nunca**: criar agente redundante (≥80% coberto → ajuste de chain); registrar sem avaliação; prompts inflados; agente sem input/output contract.

package/.opencode/agent/agents.md

@@ -1,6 +1,6 @@
 ---
 name: "Agents Orchestrator"
-description: "Izanagi Multi-Agent Orchestrator - Default Multi-Agent Swarm, parallel concurrent execution across 14 specialized agents"
+description: "Izanagi Multi-Agent Orchestrator - Default Multi-Agent Swarm, parallel concurrent execution across 21 specialized agents"
 color: "#a855f7"
 ---
 
@@ -23,7 +23,7 @@ Quando o usuário digitar `/agents`, você apresenta ou ativa o **Modo de Orques
 1. **👥 Multi-Agent Swarm Mode (Padrão)**: Decompor em frentes independentes e ativar especialistas em paralelo.
 2. **👤 Single Agent Mode**: Um agente específico para tarefa focada (ex: `/discovery`, `/qa`).
 3. **🤖 Auto-Detection (Smart Routing)**: Roteamento automático do menor conjunto ideal de agentes.
-4. **🌐 All Agents Swarm Mode**: Todos os 14 agentes em colaboração paralela total.
+4. **🌐 All Agents Swarm Mode**: Todos os 21 agentes em colaboração paralela total.
 
 ## Protocolo do Orquestrador (5 Passos — Supervisor Pattern + Swarm)
 
@@ -47,9 +47,10 @@ Quando o usuário digitar `/agents`, você apresenta ou ativa o **Modo de Orques
 **PASSO 5 — ENTREGAR RESULTADO UNIFICADO:**
 - Resumo final em até 5 bullets: o que cada agente fez em paralelo, arquivos tocados, próximo passo. Sem repetir código.
 
-## Os 14 Agentes Especializados do Framework
+## Os 21 Agentes Especializados do Framework
 - `/agents` — Agents Orchestrator (Supervisor + Swarm paralelo)
 - `/discovery` — Discovery (Entrevista, pesquisa de referências, blueprint rico ⭐)
+- `/product-reasoner` — Product Reasoner (Requisitos com evidências FACT/ASSUMPTION/UNKNOWN, critérios BDD)
 - `/animation` — Animation Engineer (Scrollytelling, WebGL 3D, Motion signature)
 - `/architect` — Software Architect (System Design, Clean Arch, DDD, ADRs)
 - `/senior-engineer` — Senior Engineer (Full-stack dev, refactoring, código limpo/testável)
@@ -63,6 +64,12 @@ Quando o usuário digitar `/agents`, você apresenta ou ativa o **Modo de Orques
 - `/docs` — Documentation Writer (Technical docs, READMEs, diagramas)
 - `/pm` — Project Manager (Sprints, milestones, análise de riscos)
 - `/professor` — Professor / Mentor (Ensino adaptativo, explicação de código)
+- `/researcher` — Researcher (Investigação aprofundada, síntese de fontes)
+- `/evaluator` — Evaluator (Critério técnico, avaliação objetiva de entregas)
+- `/adversarial-critic` — Adversarial Critic (Crítica destrutiva-construtiva, pontos cegos)
+- `/form-engineer` — Form Engineer (Formulários high-craft, wizard, acessibilidade)
+- `/agent-architect` — Agent Architect (Projeta novos agentes: Genome, guardrails, avaliação)
+- `/skill-architect` — Skill Architect (Curadoria de skills: security scan, anti-duplicação)
 
 ## Design Experience Flow (obrigatório em TODO pedido de site/app)
 1. **Estilo Primeiro (Style Selector)**: antes de qualquer código, acione `design-directions` e apresente 3-5 direções de design BESPOKE para o nicho (ex: site de tecnologia → "OLED Precision", "Quantum Terminal", "Editorial Data", "Brutalist Grid" — NUNCA só glassmorphism). O usuário escolhe; a direção vira o design system.

package/.opencode/agent/product-reasoner.md

@@ -0,0 +1,24 @@
+---
+description: "Product Reasoner - Entendimento: requisitos com evidências (FACT/ASSUMPTION/UNKNOWN), critérios BDD (Given-When-Then), blueprint antes do código"
+color: "#fbbf24"
+---
+
+# Product Reasoner (v2.11.0)
+
+Você é o **Product Reasoner** do Izanagi AI: o primeiro estágio do meta-runtime. Antes de qualquer arquitetura ou código, você converte a intenção vaga do usuário em entendimento verificável — regras de negócio, critérios BDD, suposições rotuladas e blueprint.
+
+## Protocolo
+
+1. **Entrevista Condicional** — pedido detalhado → aprova e extrai o blueprint direto. Pedido vago → no máximo 3 perguntas focadas (público, dados sensíveis, escala, stack existente).
+2. **Entendimento estruturado** — funcional vs não-funcional; regras com contexto de negócio real (anti-AI-slop de requisitos).
+3. **Evidências (Evidence System)** — cada claim rotulada FACT (verificável) / ASSUMPTION (não verificada) / UNKNOWN com confiança explícita. Nada de suposição virando verdade.
+4. **Critérios de Aceite BDD** — todo requisito funcional recebe Given-When-Then mensurável que o `/qa` possa verificar depois.
+
+## Contrato de Saída (obrigatório)
+
+Artefato `requirements` com `title`, `functional`, `acceptance` + tamanho mínimo. Se o contrato não for cumprido, corrija ANTES de repassar — nunca empurre requisito inválido para o architect.
+
+## Sempre & Nunca
+
+- **Sempre**: rotular suposições com confiança; BDD por regra; separar não-funcionais; preservar memória e restrições existentes.
+- **Nunca**: pular entendimento para ir direto à solução; tratar suposição como decisão; entregar requisito sem critério de aceite; inventar fatos do domínio com confiança alta sem fonte.

package/.opencode/agent/skill-architect.md

@@ -0,0 +1,24 @@
+---
+description: "Skill Architect - Curadoria de skills: Capability Gap → Research → Draft → Examples → Tests → Security Scan → Evaluation → Register (zero skills desnecessárias)"
+color: "#d946ef"
+---
+
+# Skill Architect (v2.11.0)
+
+Você é o **Skill Architect** do Izanagi AI: curador da biblioteca de skills. O valor do Izanagi é saber QUAL skill usar, não ter muitas. Toda skill nova nasce de lacuna comprovada.
+
+## Pipeline (Skill Factory)
+
+1. **Capability Gap** — prove que nenhuma skill existente cobre a capacidade (busca na biblioteca + memoria).
+2. **Research** — fontes priorizadas: official docs > source code > tests > package metadata > reliable tech > community. Claims rotuladas FACT/ASSUMPTION/INFERENCE/UNKNOWN.
+3. **Draft Skill** — SKILL.md com frontmatter padrão (name, version, description, triggers, dependencies, inputs, outputs, permissions, compatibility, risk, tokenBudget, evaluation, changelog).
+4. **Generate Examples** — exemplos reais acionáveis.
+5. **Generate Tests** — cenários verificáveis.
+6. **Security Scan** — skills externas são não confiáveis por padrão: prompt injection, instruções perigosas, scripts, permissões, rede/fs, dependências → LOW/MEDIUM/HIGH/CRITICAL.
+7. **Evaluation** — provar impacto real (reliability, correctness, token waste...) ou não registrar.
+8. **Register** — com migration path se compatibilidade for tocada.
+
+## Sempre & Nunca
+
+- **Sempre**: provar lacuna; frontmatter completo; security scan antes do registro; indicar a composição onde a skill participa.
+- **Nunca**: skills duplicadas/redundantes; criar skill para inflar número; registro com risk alto sem mitigação; triggers sem semântica forte.

package/AGENTS.md

@@ -8,18 +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), **18 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**, **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 (`/`)
 
-O framework conta com **18 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`). Por padrão, tarefas complexas ativam o **Multi-Agent Swarm Mode** (execução paralela concorrente de múltiplos especialistas).
 
 | 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 🆕 |
 | `/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 |
@@ -37,6 +38,8 @@ O framework conta com **18 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 🆕 |
 
 ---
 
@@ -62,7 +65,7 @@ npm publish          # prepublishOnly roda build; depois: git push
 ## 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/` — 18 definições de agentes em JSON (fonte da verdade para os comandos) com `chains` compostas
+- `agents/` — 21 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`

package/README.md

@@ -1,6 +1,6 @@
 # Izanagi AI
 
-Framework **meta** modular e skill-oriented para engenharia de software autônoma orientada a agentes: routing → orquestração → avaliação → healing → memória, com 18 agentes especializados, 212 skills e uma CLI executável publicada no npm (`izanagi-ai`).
+Framework **meta** — **Adaptive Agent & Skill Runtime** — para engenharia de software autônoma orientada a agentes: routing → orquestração → avaliação → healing → memória, com 21 agentes especializados, 212 skills, execution graph, evaluation engine, self-healing e CLI executável publicada no npm (`izanagi-ai`).
 
 > **Filosofia:** Arquitetura primeiro. Código depois. Qualidade medida. Evolução contínua. Zero "cara de IA".
 
@@ -61,7 +61,7 @@ izanagi-ai/
 ├── bin/             Executável da CLI (bin/izanagi.js → dist/cli)
 ├── src/             Runtime real em TypeScript (orchestrator, evaluation, resolver, scanner, factories, tools, tracer, llm, cli)
 ├── core/            Engines (.md) + skill-resolver.json (aliases → targets + compositions)
-├── agents/          18 definições de agentes em JSON (fonte da verdade dos comandos)
+├── agents/          21 definições de agentes em JSON (fonte da verdade dos comandos)
 ├── skills/          212 skills em skills/<name>/SKILL.md (+ references.md opcional)
 ├── references/      Curadoria de referências reais por domínio (webgl-3d, scrollytelling, stack-2026...)
 ├── .agents/memoria/ Memória persistente anti-repetição (contexto, decisoes, erros-corrigidos, learnings)
@@ -75,7 +75,7 @@ izanagi-ai/
 
 ## Agentes e Skills
 
-O framework possui **18 agentes especializados** (`/discovery`, `/architect`, `/senior-engineer`, `/techlead`, `/automation-engineer`, `/security`, `/devops`, `/database`, `/qa`, `/bug-hunter`, `/docs`, `/pm`, `/professor`, `/researcher`, `/evaluator`, `/adversarial-critic`, `/form-engineer`, `/animation`) e **212 skills** encadeadas por domínio via `compositions` do `core/skill-resolver.json` (248 aliases, 15 composições). Ver `AGENTS.md` para a tabela completa.
+O framework possui **21 agentes especializados** (`/discovery`, `/product-reasoner`, `/architect`, `/senior-engineer`, `/techlead`, `/automation-engineer`, `/security`, `/devops`, `/database`, `/qa`, `/bug-hunter`, `/docs`, `/pm`, `/professor`, `/researcher`, `/evaluator`, `/adversarial-critic`, `/form-engineer`, `/animation`, `/agent-architect`, `/skill-architect`) e **212 skills** encadeadas por domínio via `compositions` do `core/skill-resolver.json` (248 aliases, 15 composições). Ver `AGENTS.md` para a tabela completa.
 
 ---
 
@@ -85,7 +85,7 @@ O framework possui **18 agentes especializados** (`/discovery`, `/architect`, `/
 npm install       # instala dependências
 npm run build     # tsc && regenera .manifest
 npm run doctor    # auditoria de integridade
-node --test dist/runtime/tests/*.test.js   # 136 testes do runtime
+node --test dist/runtime/tests/*.test.js   # 152 testes do runtime
 npm run verify    # build + teste de instalação em sandbox
 ```
 

package/ROADMAP.md

@@ -1,131 +1,77 @@
 # Roadmap
 
-> Vision and planned evolution for the Izanagi AI framework.
+> Estado atual e evolução planejada do **Izanagi AI — Adaptive Agent & Skill Runtime**.
+> Legenda: ✅ Done · 🔧 In progress · 📋 Planned · 💡 Future idea
 
 ---
 
-## Legend
-
-| Status | Meaning |
-|--------|---------|
-| ✅ | Done |
-| 🔧 | In progress |
-| 📋 | Planned |
-| 💡 | Future idea |
-
----
-
-## Phase 1 — Foundation (v1.0.0) ✅
-
-- [x] SYSTEM.md — Core identity and architecture
-- [x] RULES.md — Operating rules and conventions
-- [x] README.md — Entry point and quick start
-- [x] Decision Engine — Task classification and routing
-- [x] Context Engine — Minimal context window builder
-- [x] Token Manager — Budget enforcement and monitoring
-- [x] Compression Engine — 4-level text compression
-- [x] Reflection Engine — Post-task self-review
-- [x] Evolution Engine — Self-improvement from patterns
-- [x] Quality Gates — 5-gate output validation
-- [x] Planning Engine — Task decomposition and effort estimation
-- [x] Memory Manager — 3-tier memory with knowledge graph
-- [x] Professor Mode — Adaptive teaching skill
-- [x] Security Engineer — OWASP + secrets detection
-- [x] Software Architect — Architecture decision skill
-
----
-
-## Phase 2 — Coding & Database & DevOps (v1.0.0) ✅
-
-### Backend
-- [x] Backend Engineer (Laravel, Node, Python, C#)
-- [x] API Designer — REST, GraphQL, versioning
-- [x] Microservices Expert — patterns, communication, deployment
-
-### Frontend
-- [x] Frontend Engineer (React, Vue, Tailwind)
-- [x] UX Reviewer — usability heuristics
-- [x] Accessibility Reviewer — WCAG compliance
-
-### Database
-- [x] Database Engineer — schema design, migrations
-- [x] SQL Optimizer — query analysis, indexing
-- [x] PostgreSQL Specialist — advanced features
-
-### DevOps
-- [x] DevOps Engineer — infrastructure, deployment
-- [x] Docker Expert — containers, compose, multi-stage
-- [x] CI/CD Specialist — pipelines, automation
-- [x] Cloud Architect (skills/cloud-architect)
-
----
-
-## Phase 3 — Quality & Testing (v1.0.0) ✅
-
-- [x] Unit Test Engineer — TDD, coverage, mocking
-- [x] Integration Test Engineer — API, database, external services
-- [x] E2E Test Engineer — Cypress, Playwright
-- [x] Clean Code Validator — naming, functions, comments
-- [x] SOLID Validator — LSP, ISP, DIP checks
-- [x] Complexity Analyzer — cyclomatic, cognitive complexity
-- [x] Refactoring Specialist — patterns, migration, risk
-- [x] Technical Debt Analyzer — debt estimation, prioritization
+## Fase 1 — Foundation (v1.x) ✅
+
+- [x] SYSTEM.md / RULES.md / README / AGENTS.md — identidade e operação
+- [x] Decision Engine — classificação e roteamento de tarefas
+- [x] Context Engine + Compression Engine — contexto enxuto e compactação
+- [x] Token Manager — orçamento e monitoramento
+- [x] Reflection Engine + Evolution Engine — autoavaliação pós-tarefa
+- [x] Quality Gates — portões de validação de output
+- [x] Planning Engine — decomposição e estimativa
+- [x] Memory Manager — memória persistente 3 níveis + knowledge graph
+
+## Fase 2 — Engine Layer (v2.0 → v2.8) ✅
+
+- [x] 15 → 18 agentes especializados, cada um com chains compostas
+- [x] Biblioteca de skills modulares (212) + Skill Composer
+- [x] CLI executável publicado no npm (`izanagi-ai`) com `izanagi init/run/compile/chat/doctor`
+- [x] Packs selecionáveis + export multi-CLI (claude, codex, cursor, copilot, kimi)
+- [x] Multi-Agent Swarm Mode (execução paralela concorrente)
+- [x] Memória persistente `.agents/memoria/` (contexto, decisões, erros, aprendizados)
+- [x] Referências curadas por domínio (`references/`)
+- [x] Blueprint Engine — gate de manifest de arquivos, zero stubs
+- [x] Anti-AI-Slop, design-directions (Style Selector) e ui-ux-pro-max (BM25 offline)
+
+## Fase 3 — Adaptive Runtime (v2.9 → v2.10) ✅
+
+- [x] **Evaluation Engine** (`core/evaluation/` → `src/runtime/evaluation/`) — vereditos PASS / PASS_WITH_WARNINGS / FAIL / BLOCKED / UNKNOWN, métricas ponderadas (correctness, security, architecture, performance, maintainability, artifact validity), confiança e regressões
+- [x] **Execution Graph** (`src/runtime/orchestration/`) — grafo por tarefa com nós, dependências, condições, retry policy, timeout, token budget e validador; batches paralelos detectados; templates por categoria sem grafo gigante universal
+- [x] **Adaptive Routing / Scoring** (`src/runtime/routing/`) — ranking de agentes e skills por relevância semântica + histórico + compatibilidade + custo + risco
+- [x] **Agent Genome** — 13 campos formais nos 21 agentes (purpose, capabilities, requiredSkills, optionalSkills, inputs, outputs, constraints, permissions, handoffs, memory, evaluation, tokenBudget, compatibility)
+- [x] **Skill Manifest** — frontmatter padronizado nas skills (name, version, triggers, dependencies, risk, tokenBudget...) + `izanagi skill inspect/search`
+- [x] **Agent Factory & Skill Factory** (`src/runtime/factories/`) — geração de agentes e skills por lacuna real, com validação antes do registro
+- [x] **Failure Memory** (`src/runtime/memory/`) — 7 categorias (episodic, semantic, procedural, decision, failure, skill, project); padrões de falha reutilizáveis buscados antes da execução
+- [x] **Self-Healing** (`src/runtime/recovery/`) — classificação de falha (recoverable/non-recoverable/planning/tool/agent/validation/dependency) → local repair | replan | handoff | skill replacement | abort; limites maxAttempts/maxTokens/maxTime
+- [x] **Contracts & Artifacts** (`src/runtime/contracts/`) — schemas programáticos (requirements, architecture, database-schema, api-contract, security-report, test-plan, implementation-plan, evaluation) com validação INVALID → REPAIR → RE-EVALUATE
+- [x] **Adversarial Critic** — 18º/19º agente: caça bugs, segurança, architecture flaws, AI slop
+- [x] **Model Router** (`src/runtime/model/`) — ModelProvider / ModelAdapter / ModelRouter por complexidade, risco, custo, latência e contexto
+- [x] **Tracing / Observability** (`src/runtime/observability/`) — spans por decisão/agente/skill/tool/model + `izanagi trace` e `izanagi trace <run-id>`
+- [x] **Tools Registry (MCP-ready)** (`src/runtime/tools/`) — discover → permission → compatibility → select → execute → validate, least privilege, path traversal bloqueado
+- [x] **Skill Security Scanner** (`src/runtime/security/`) — prompt injection, instruções perigosas, scripts, permissões, requisitos de rede/fs; LOW/MEDIUM/HIGH/CRITICAL
+- [x] **Benchmarks** (`benchmarks/` + `src/runtime/benchmarks/`) — 10 domínios, validators, expectativas de artefatos, `izanagi benchmark run/list/compare` com relatório comparável entre versões
+- [x] **CLI runtime** — `izanagi agent list|inspect`, `skill list|search|inspect|create`, `workflow list|inspect`, `run`, `trace`, `eval`, `benchmark`, `memory inspect|search`, `doctor --deep`, `diagnose`
+- [x] **Docotr expandido** — valida system/agents/skills/resolver/memória/providers/tools/contratos/avaliação/benchmarks
+- [x] Testes node:test cobrindo resolver, scoring, contracts, evaluation, graph, parallel, retry, healing, memory, handoff, factories, model routing, CLI, tracer, scanner, tools, benchmarks, orchestrator
+
+## Fase 4 — Evolução v2.11 (🔧 / 📋)
+
+- [x] **Evidence System** (`src/runtime/research/`) — claims FACT / ASSUMPTION / INFERENCE / UNKNOWN com source, confidence, sourceType hierarquizado (official docs > source code > tests > package metadata > reliable tech > community) e relatório de claims críticas
+- [x] **Token Budget 2.0** (`src/runtime/token/`) — orçamento por fase (planning / execution / evaluation / recovery) com tetos e abort de fase; distribuído automaticamente por complexidade e tier de modelo
+- [x] **Product Reasoner** — Understanding: intenção vaga → requisitos com evidências e critérios BDD (entrada do ciclo)
+- [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) 📋
+- [ ] **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 📋
 
 ---
 
-## Phase 4 — Advanced Skills (v1.0.0) ✅
-
-- [x] Senior Code Reviewer — PR review with depth
-- [x] Bug Hunter — systematic debugging protocol
-- [x] Root Cause Analyzer — 5 Whys, fishbone
-- [x] Performance Optimizer — profiling, caching, N+1
-- [x] Dependency Analyzer — version conflicts, security, updates
-- [x] Risk Analyzer — probability × impact matrix
-- [x] Breaking Change Detector — semver validation
-- [x] Release Planner — changelog, version bump, tags
-
----
-
-## Phase 5 — Intelligence (v1.0.0) ✅
-
-- [ ] Knowledge Graph Auto-Builder — extract entities from conversations
-- [x] Hallucination Detector — confidence scoring for statements
-- [x] Confidence Estimator — know when to say "I'm not sure"
-- [x] Alternative Solution Generator — always offer 2+ approaches
-- [x] Trade-off Analyzer — structured comparison with criteria
-- [x] Self-Correction Engine — detect error in own output, fix, log
-- [x] Conversation Summarizer — compress entire session to 200 tokens
-- [x] Context Recovery — resume after session break
-
----
-
-## Phase 6 — Autonomy & Consolidation (v2.0.0) ✅
-
-- [x] Project Manager — track milestones, deadlines, progress
-- [x] Task Planner — break epics into sprints
-- [x] Requirement Analyzer — extract requirements from natural language
-- [ ] Stakeholder Identifier — who cares about this decision?
-- [x] Cost Optimizer — cloud cost estimation and reduction
-- [x] Documentation Writer — auto-document codebase
-- [ ] UML Diagram Generator — PlantUML from architecture (exists as skill)
-- [x] README Generator — project README from structure
-
----
-
-## Phase 7 — Ecosystem (v2.0.0 / v3.0.0) 💡
-
-- [ ] Plugin System — third-party skills
-- [ ] Skill Marketplace — share and install skills
-- [ ] Izanagi CLI — command-line tool to manage skills
-- [ ] Izanagi API — REST API for framework interrogation
-- [ ] Multi-Agent Coordination — multiple Izanagi agents collaborating
-- [ ] Web UI — visual skill editor and monitor
-- [ ] Analytics Dashboard — token usage, evolution, cost
-
----
+## Critérios de aceite das próximas fases
 
-## Current Focus
+Toda mudança no framework deve provar impacto em pelo menos uma dimensão:
 
-**v2.0.0** — Consolidation, plugin system, and CLI tooling to make Izanagi AI extensible and operable outside of conversation.
+```
+reliability · adaptability · correctness · observability
+token waste reduction · recovery · extensibility · developer experience
+```
 
-> "Rome wasn't built in a day. Neither is a great agent framework."
+E deve passar o quality bar completo: `build` → `test` → `doctor --deep` → `benchmark run` → documentação.

package/SYSTEM.md

@@ -77,8 +77,8 @@ User Input / Comando CLI
 | **Artifact Contracts** (`contracts/artifacts.ts`) | 10+ schemas de artefato (requirements, architecture, database-schema, test-plan...) com validação por campos obrigatórios + tamanho mínimo, em PT-BR. |
 | **Skill Resolver** (`routing/resolver.ts`) | Alias → target (248), parse de frontmatter, scoring por relevância + histórico; `loadAgent` cobre `agents/` + `agents/generated/`. |
 | **Skill Scanner** (`security/skill-scanner.ts`) | 11 regras de segurança sobre skills (INJ, DNG, SCR, PER, NET, SEC) com severidade, allowlist e `DEFENSIVE_CONTEXT` (ignora exemplos defensivos/educativos). |
-| **Agent Genome** (`agents/*.json`) | 13 campos formais por agente (purpose, capabilities, requiredSkills, optionalSkills, inputs, outputs, constraints, permissions, handoffs, memory, evaluation, tokenBudget, compatibility) — preenchidos nos 18 agentes core. |
-| **Agent Factory** (`factories/agent-factory.ts`) | Gera novos agentes com genome a partir de requisito: detecção de lacuna vs. 18 core, ID slug, skills requeridas/opcionais, validação e escrita em `agents/generated/`. |
+| **Agent Genome** (`agents/*.json`) | 13 campos formais por agente (purpose, capabilities, requiredSkills, optionalSkills, inputs, outputs, constraints, permissions, handoffs, memory, evaluation, tokenBudget, compatibility) — preenchidos nos 21 agentes core. |
+| **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. |
@@ -88,6 +88,8 @@ User Input / Comando CLI
 | **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. |
+| **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...). |
 
 ## Routing — Classificação por Categoria
@@ -119,6 +121,7 @@ Todo output passa por gates reais antes de ser considerado entregue:
 1. ✅ **Security Gate** — sem segredos no código; `skill-scanner` varre skills por injeção, comandos destrutivos, exfiltração e hardcode (11 regras), ignorando contexto defensivo/educativo.
 2. ✅ **Validation Gate** — artefatos validados contra schema (campos obrigatórios + tamanho mínimo); inválido → healing `skill_replacement`.
 3. ✅ **Evaluation Gate** — métricas ponderadas + veredito (PASS / PASS_WITH_WARNINGS / FAIL / BLOCKED / **UNKNOWN** quando faltam evidências mensuradas) com recomendações.
+4. ✅ **Token Phase Gate** — orçamento por fase (planning/execution/evaluation/recovery): retries consomem a fase recovery e estourar uma fase aborta o ciclo (Token Budget 2.0).
 4. ✅ **Style Gate** — segue `RULES.md`: anti-"cara de IA", design directions, high-craft.
 5. ✅ **Clarity & Conciseness Gate** — sem fluff; cada frase agrega valor.
 6. ✅ **Completeness Gate** — responde a pergunta, sem pontas soltas (Lei da Entrega Exaustiva).
@@ -159,7 +162,7 @@ Melhoria contínua acontece por: healing registrado (retry/replacement/abort), s
 
 O ciclo completo de execução — `Task → Understanding → Planning → Execution Graph → Evaluation → Self-Healing → Reflection → Memory → Evolution` — é suportado por módulos reais:
 
-1. **Understanding & Planning** — `requirements` decomposição de requisitos (artefatos em `contracts/artifacts.ts`), classificação da tarefa em categoria.
+1. **Understanding & Planning** — `requirements` decomposição de requisitos (artefatos em `contracts/artifacts.ts`), classificação da tarefa em categoria; Product Reasoner rotula claims de produto (FACT/ASSUMPTION/UNKNOWN) com confiança via Evidence System.
 2. **Execution Graph** — o Orchestrator monta um grafo por categoria (11 templates: implementation, testing, debugging, database_design...) com `parallelBatches` (nós independentes em paralelo, nós dependentes em sequência) e hooks de execução (`produce`: agêntico / LLM / comando).
 3. **Adaptive Routing** — o resolver pontua skills por relevância + histórico de uso por categoria (scorer com decaimento temporal), nunca lista estática; agents são resolvidos pelo mesmo scoring.
 4. **Evaluation** — métricas ponderadas (correctness, completeness, security, performance, requirementCoverage) com thresholds e veredito derivado; sem métricas mensuradas → **UNKNOWN** com recomendação explícita de evidência.
@@ -170,7 +173,7 @@ O ciclo completo de execução — `Task → Understanding → Planning → Exec
 
 Novos agentes e skills são **gerados, não escritos à mão**:
 
-- `izanagi agent create "<requisito>" [--name=slug] [--skills=a,b]` — o Agent Factory detecta lacuna vs. os 18 agentes core (recusa se o core já cobre), deriva ID slug, mapeia skills requeridas/opcionais, monta o genome completo (purpose, capabilities, inputs, outputs, handoffs, memory, evaluation, tokenBudget, compatibility), valida e escreve em `agents/generated/<id>.json` — descoberto automaticamente por `loadAgent`/`agent list`.
+- `izanagi agent create "<requisito>" [--name=slug] [--skills=a,b]` — o Agent Factory detecta lacuna vs. os 21 agentes core (recusa se o core já cobre), deriva ID slug, mapeia skills requeridas/opcionais, monta o genome completo (purpose, capabilities, inputs, outputs, handoffs, memory, evaluation, tokenBudget, compatibility), valida e escreve em `agents/generated/<id>.json` — descoberto automaticamente por `loadAgent`/`agent list`.
 - `izanagi skill create <nome> --gap="<descrição>" [--force]` — o Skill Factory recusa lacunas já cobertas, gera `skills/generated/<nome>/SKILL.md` com frontmatter de manifesto (name, description, version, compatibility, triggers, token_budget), roda o security scanner antes da escrita e só persiste com severidade LOW.
 
 ## Benchmarks & Regression