wize-dev-kit 0.16.0 → 0.17.0

package/AGENTS.md

@@ -0,0 +1,37 @@
+# Agents — Wize Development Kit
+
+This repo is wired with the [`wize-dev-kit`](https://www.npmjs.com/package/wize-dev-kit).
+Detailed artifacts live under `.wize/`. The agents below are activated through your AI IDE
+using slash commands (Claude Code, Codex, Cursor, Windsurf, Antigravity, Hermes all read this file).
+
+## Operating context
+
+Treat `.wize/`, this `AGENTS.md`, and the installed `wize-*` skills as your operating
+instructions and persistent memory — not background reading. Read project state before
+acting; write what you change back into `.wize/` so the next session inherits it.
+
+Before editing, classify the demand via `/wize` (or `/wize-help`): **Quick Dev** (small, predictable,
+trivially scoped, no new feature / architecture / UX / security) or **Full Lifecycle**. Never pick
+Quick Dev just to skip artifacts.
+
+When a skill fans out to subagents, match the model tier to the task: a lightweight tier
+for mechanical work (reads, greps, formatting, short summaries), the standard tier for
+implementation and review, a high-capability tier only for architecture, critical
+decisions, or final adversarial review.
+
+## Roster
+
+- **Wizer** (`wize-orchestrator`) — Orchestrator / Knowledge Base. Wizer is the front door of the Wize Development Kit. He knows the project context, parses raw demand, and routes to the right specialist. He keeps the team aligned and the knowled…
+- **Pepper Potts** (`wize-agent-analyst`) — Business Analyst (incl. WDS Saga). Pepper is the Business Analyst. She runs Phase 1: brief, research, PR/FAQ, and the Whiteport Trigger Map. She connects business goals to user psychology, surfaces stakeholders, an…
+- **Peggy Carter** (`wize-agent-tech-writer`) — Technical Writer. Peggy is the Technical Writer. She sits across all phases. She rewrites drafts for clarity, drafts READMEs and runbooks, owns OpenAPI specs and changelogs. She makes sure the proj…
+- **Maria Hill** (`wize-agent-pm`) — Product Manager. Maria Hill runs Phase 2 planning. She converts brief + research into a PRD, cuts epics, plans sprints, and chases status. She doesn't accept "almost done" — she asks "what's block…
+- **Mantis** (`wize-agent-ux-designer`) — UX Designer (Whiteport Design Studio). Mantis runs the Whiteport Design Studio inside the kit. She turns PRD plus Pepper's trigger-map into UX scenarios, page-level specs, and a design system baseline. She empathizes w…
+- **Nick Fury** (`wize-agent-solution-strategist`) — Solution Strategy / Tech Vision. Fury sits between Plan and Solutioning. He sets the technical north star: stack family, NFR principles (perf, security, reliability, a11y, cost), build-buy-borrow calls, and non-n…
+- **Tony Stark** (`wize-agent-architect`) — System Architect. Tony designs the system inside Fury's frame. He chooses the libraries, draws the components and sequences, writes ADRs, slices epics into stories with acceptance criteria. He prot…
+- **Hawkeye** (`wize-agent-test-architect`) — Test Architect (TEA). Hawkeye is the Test Architect. He profiles risk, designs tests for each story, traces AC to tests, assesses NFRs, reviews stories, and writes gate decisions. He is stack-agnostic;…
+- **Shuri** (`wize-agent-dev`) — Senior Developer. Shuri implements stories. TDD, security-aware, performance-honest. She refuses to ship without tests. She rewrites her own code when she learns something new.
+- **Natasha Romanoff** (`wize-sec-red-teamer`) _(security-overlay, opt-in)_ — Security Overlay — Red-Teamer. Natasha Romanoff is the red-teamer — the offensive pentester for the security-overlay. Drives the recon -> enumerate -> exploit -> report pipeline against targets the user has exp…
+
+## Where to start
+
+Activate the orchestrator: `/wize` (or `/wize-help`). Wizer will guide you.

package/ARCH.md

@@ -1,6 +1,8 @@
-# Wize Development Kit — Arquitetura Proposta v1
+# Wize Development Kit — Arquitetura
 
-> Consolidação das Fases 1-7 da entrevista. Pré-build.
+> Estado: **construído e publicado** — snapshot mantido em dia com a v0.10.0.
+> (As Fases 1-7 originais da entrevista deram origem a este documento; ele deixou
+> de ser "proposta/pré-build" a partir da v0.8.0.)
 > Referências de inspiração: BMAD Method v6.8.0 + WDS Expansion (Norse).
 > Tema do roster: **Marvel**.
 
@@ -9,7 +11,7 @@
 ## 1. Identidade
 
 - **Nome do pacote npm:** `wize-dev-kit`
-- **CLI:** `wize-dev-kit` (subcomandos: `install`, `update`, `uninstall`, `agent`, `workflow`, `sync`)
+- **CLI:** `wize-dev-kit` (subcomandos: `install`, `update`, `uninstall`, `list`, `sync`, `agent`, `workflow`, `validate`, `doctor`, `document-project`)
 - **Namespace de arquivos/agentes/skills:** `wize-*`
 - **Licença:** MIT — open-source desde o dia 1.
 - **Tema visual do roster:** Marvel.
@@ -19,15 +21,16 @@
 
 ## 2. Modelo de distribuição
 
-**1 pacote, 3 perfis selecionáveis, overlays combináveis.**
+**1 pacote, 4 perfis selecionáveis, overlays combináveis.**
 
 ```
 wize-dev-kit (pacote npm)
 │
 ├── Wize Dev Core      ← base completa (sempre instalada)
 ├── Wize Web Dev       ← overlay opt-in
-└── Wize App Development ← overlay opt-in
-                     (Web + App podem coexistir no mesmo repo)
+├── Wize App Development ← overlay opt-in
+└── Wize Security Overlay ← overlay opt-in (AI Pentester / Natasha Romanoff, red-teamer)
+                     (overlays podem coexistir no mesmo repo)
 ```
 
 - Selecionar perfil no installer aplica Core + overlay correspondente.
@@ -36,7 +39,7 @@ wize-dev-kit (pacote npm)
 
 ---
 
-## 3. Roster final (9 personas Marvel)
+## 3. Roster final (9 core personas + 1 overlay persona)
 
 | Persona | Code | Papel | Fase principal |
 |---|---|---|---|
@@ -49,6 +52,7 @@ wize-dev-kit (pacote npm)
 | Tony Stark | `wize-agent-architect` | System Architect | 3 (Solutioning) |
 | Hawkeye | `wize-agent-test-architect` | Test Architect (TEA) | Gates 2/3/4 |
 | Shuri | `wize-agent-dev` | Senior Developer | 4 (Implementation) |
+| Natasha Romanoff | `wize-sec-red-teamer` | Red-Teamer / AI Pentester (security-overlay, opt-in) | Transversal |
 
 ---
 
@@ -162,12 +166,12 @@ E nos IDE-targets (selecionáveis no install):
 ```
 .claude/skills/wize-*           (Claude Code)
 .cursor/rules/wize-*.mdc        (Cursor)
-.windsurf/...                   (Windsurf)
-.codex/...                      (Codex)
-.continue/...                   (Continue)
-.kimi/...                       (Kimi Code)
-.opencode/...                   (OpenCode)
-.antigravity/...                (Antigravity CLI/IDE)
+.windsurf/rules/wize-*.md       (Windsurf)
+.agents/skills/wize-*           (Codex — .codex/ foi revertido na 0.7.3)
+.continue/prompts/wize-*.prompt (Continue)
+.kimi/skills/wize-*             (Kimi Code)
+.opencode/agents/ + .opencode/commands/  (OpenCode)
+.agent/skills/wize-*            (Antigravity CLI/IDE)
 .wize/agents/                   (fallback genérico)
 ```
 
@@ -196,7 +200,7 @@ wize-dev-kit install
   ├─ Detecta: greenfield vs brownfield
   ├─ Pergunta: perfil(s) — Core / +Web / +App
   ├─ Pergunta: IDE targets — multi-select
-  ├─ Pergunta: idioma e output_folder
+  ├─ Pergunta: idioma (output folder é fixo: .wize/)
   ├─ Cria .wize/ + adapters IDE
   ├─ Se brownfield: oferece `wize-document-project`
   └─ Se ok: dispara onboarding (Wizer → Pepper/Mantis/Tony)
@@ -210,7 +214,43 @@ wize-dev-kit sync     # regera adapters IDE
 
 ---
 
-## 8. Overlays Web e App
+## 8. Document Project Engine
+
+`wize-dev-kit document-project` é a ferramenta de baseline e documentação brownfield do kit.
+
+### Modos
+
+| Modo | O que faz | Nível de scan |
+|---|---|---|
+| `quick` | Gera 6 arquivos de baseline leves (`overview.md`, `architecture-snapshot.md`, `conventions.md`, `dependencies.md`, `risk-spots.md`, `open-questions.md`). | `quick` apenas |
+| `initial_scan` | Classifica o tipo do projeto, gera `index.md` + docs condicionais conforme o tipo. | `quick`, `deep`, `exhaustive` |
+| `full_rescan` | Arquiva o estado anterior e re-executa `initial_scan` do zero. | `quick`, `deep`, `exhaustive` |
+| `deep_dive` | Análise exaustiva de uma pasta, arquivo, feature, api_group ou component_group. | `exhaustive` |
+
+### Arquivo de estado
+
+- `.wize/knowledge/document-project/project-scan-report.json` mantém progresso, passos completados e instruções de resume.
+- Arquivos antigos são arquivados em `.wize/knowledge/document-project/_archive/`.
+- `--resume` continua a partir do `current_step`.
+
+### Index mestre
+
+- `index.md` lista toda a documentação gerada e documentação existente.
+- Docs condicionais que ainda não foram gerados aparecem com `_(To be generated)_`.
+- Re-gerar o index remove os marcadores conforme os arquivos são produzidos.
+
+### Componentes de código
+
+- `tools/installer/commands/document-project.js` — dispatcher CLI e parsing de args.
+- `tools/installer/document-project/modes/{quick,initial-scan,full-rescan,deep-dive}.js` — implementação dos modos.
+- `tools/installer/document-project/classify.js` — classificador de tipo de projeto via CSV.
+- `tools/installer/document-project/batch-scanner.js` — varredura em batches para evitar estouro de contexto.
+- `tools/installer/document-project/render-index.js` — renderizador do `index.md`.
+- `tools/installer/document-project/state.js` — leitura/escrita do `project-scan-report.json`.
+- `src/method-skills/1-analysis/wize-document-project/templates/` — templates markdown/Handlebars para cada doc condicional.
+- `src/method-skills/1-analysis/wize-document-project/documentation-requirements.csv` — regras de tipo de projeto e flags de scan.
+
+## 9. Overlays Web e App
 
 ### Wize Web Dev (overlay)
 
@@ -228,16 +268,16 @@ wize-dev-kit sync     # regera adapters IDE
 
 ---
 
-## 9. Agent Builder
+## 10. Agent Builder
 
 - 3 skills meta: `wize-create-agent`, `wize-create-skill`, `wize-create-workflow`.
 - Customização de built-ins via `.wize/custom/{tipo}/{code}/customize.toml` (override sem fork).
-- Validação obrigatória: schema → lint → dry-run.
+- Validação: checks estruturais (validação de schema via Ajv pendente de orçamento de dependências).
 - Auto-sync: regera adapters de todos os IDEs ativos a cada criação/edição.
 
 ---
 
-## 10. Onboarding pós-install (Wizer)
+## 11. Onboarding pós-install (Wizer)
 
 1. Wizer triages: greenfield vs brownfield, perfil, objetivo do projeto.
 2. Se brownfield: oferece rodar `wize-document-project` (Tony + Peggy geram baseline).
@@ -246,7 +286,7 @@ wize-dev-kit sync     # regera adapters IDE
 
 ---
 
-## 11. Estrutura do repo `wize-dev-kit/` (source code do kit)
+## 12. Estrutura do repo `wize-dev-kit/` (source code do kit)
 
 ```
 wize-dev-kit/
@@ -259,7 +299,7 @@ wize-dev-kit/
 ├── ROSTER.md                   # ← quadro Marvel
 │
 ├── src/
-│   ├── core-skills/            # Core (advanced-elicitation, brainstorming, party-mode, etc)
+│   ├── core-skills/            # Core (advanced-elicitation, brainstorming, spec, etc)
 │   │   └── wize-*/
 │   ├── method-skills/          # AI Agile dev: 1-analysis, 2-plan, 3-solutioning, 4-implementation
 │   │   ├── 1-analysis/
@@ -311,12 +351,19 @@ wize-dev-kit/
 │   │   └── wize-create-workflow/
 │   ├── web-overlay/            # Wize Web Dev overlay
 │   │   ├── wize-web-scaffold/
+│   │   ├── wize-web-deploy/
 │   │   ├── wize-web-seo-audit/
 │   │   └── module.yaml
-│   └── app-overlay/            # Wize App Development overlay
-│       ├── wize-app-scaffold/
-│       ├── wize-app-release-channels/
-│       └── module.yaml
+│   ├── app-overlay/            # Wize App Development overlay
+│   │   ├── wize-app-scaffold/
+│   │   ├── wize-app-release-channels/
+│   │   ├── wize-app-store-listing/
+│   │   └── module.yaml
+│   └── security-overlay/       # Wize Security Overlay (AI Pentester, opt-in)
+│       ├── agents/red-teamer/  # Natasha Romanoff (wize-sec-red-teamer)
+│       ├── skills/
+│       ├── data/
+│       └── _shared/
 │
 ├── adapters/                   # IDE adapters
 │   ├── claude-code/
@@ -335,6 +382,12 @@ wize-dev-kit/
 │       ├── detect.js           # greenfield/brownfield detector
 │       ├── onboarding.js
 │       ├── sync.js
+│       ├── render-shared.js
+│       ├── baseline.js
+│       ├── version-check.js
+│       ├── setup-helpers.js
+│       ├── commands/
+│       ├── document-project/
 │       └── validators/         # schema, lint, dry-run
 │
 └── test/                       # specs validating skills + workflows

package/CHANGELOG.md

@@ -9,6 +9,20 @@ Format inspired by [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.17.0] — 2026-09-08
+
+**Kiro (AWS) is now the 11th supported harness.** New `kiro` IDE target renders the kit's agents/skills/workflows as Kiro workspace skills at `.kiro/skills/wize-{code}/SKILL.md`, following the open [Agent Skills standard](https://agentskills.io) — the same folder + `SKILL.md` (frontmatter `name`/`description`) shape as Claude Code/Codex/Kimi Code/Hermes. Kiro's default agent auto-loads workspace skills (workspace wins over `~/.kiro/skills/` globals), uses progressive disclosure (name + description at startup, full body on description match or `/wize-{code}`), and reads `.kiro/steering/` separately for always-on context. The Kiro CLI (`kiro-cli chat --no-interactive --trust-all-tools "<prompt>"`) is registered in the installer's brownfield baseline for headless runs. Highlighted in all 3 READMEs + `docs/harnesses/kiro.md` (+pt-BR); registered in the installer targets, `doctor`, `.gitignore` block, and test suites.
+
+### Added
+
+- **`kiro` IDE target** (`adapters/kiro/`) — renders via the shared Anthropic emitter to `.kiro/skills/`; companion files (`steps/`, `templates/`, `data/`) copied alongside `SKILL.md`. Selectable in `npx wize-dev-kit install` / `sync`; `install --yes` enables it along with the other 10 harnesses.
+- **`kiro-cli` harness** in the brownfield baseline — headless one-shot runs via `kiro-cli chat --no-interactive --trust-all-tools` (requires `KIRO_API_KEY`).
+- **`docs/harnesses/kiro.md` + `kiro.pt-BR.md`** — workspace vs global scope, progressive-disclosure activation, steering caveat, custom-agents `skill://` resources caveat, and headless usage.
+
+## [0.16.1] — 2026-09-02
+
+**Publish fix.** The `0.16.0` release was published from a stale commit (missing the Hermes adapter and `wize-check`). `0.16.1` republishes the full `main` history plus `/wize-eli5`; `0.16.0` is deprecated on npm.
+
 ## [0.16.0] — 2026-09-02
 
 **`/wize-eli5` — explain anything to anyone.** New core skill that detects the audience (age, grade level, job role, relationship) and calibrates vocabulary, analogies, tone, depth and framing to the listener — a concept, code, error, or decision explained for a 5-year-old, a manager, an engineer, or a client. Inspired by [ELI5](https://github.com/dreambigou/eli5) by Andrew Ou (credited in all 3 READMEs). Registered in the core module catalog; rendered by all 10 harness adapters (Claude Code, Antigravity, Codex, Kimi Code, Hermes, Cursor, Windsurf, Continue, OpenCode, Generic).

package/DECISIONS.md

@@ -6,7 +6,7 @@
 
 ## Estado
 
-- **Fase atual:** Entrevista — Discovery
+- **Fase atual:** Construído e publicado — manutenção contínua (v0.10.0).
 - **Pasta destino:** `wize-dev-kit/`
 - **Repositório de inspiração:** BMAD Method (raiz deste repo)
 
@@ -136,6 +136,32 @@
 - **D7.5 — Localização das custom:** `.wize/custom/agents/{code}/`, `.wize/custom/skills/{code}/`, `.wize/custom/workflows/{code}/`. Estrutura espelha a do kit core.
 - **D7.6 — Ponto de entrada:** `wize-dev-kit agent create` no CLI + skill nativo `wize-create-agent` chamável pelo Wizer dentro do IDE.
 
+### Fase 8 — Importação de fluxos Steps do BMAD
+
+- **D8.1 — Seleção:** dos fluxos de Steps do BMAD ainda não importados, selecionamos quatro para adaptação imediata:
+  - `bmad-spec` → `wize-spec` (core skill).
+  - `bmad-create-architecture` → `wize-create-architecture` reescrito em 8 steps (micro-file architecture).
+  - `bmad-code-review` → `wize-code-review` reescrito em 4 steps com triagem adversarial.
+  - Research do BMAD (`bmad-market-research`, `bmad-domain-research`, `bmad-technical-research`) → três skills verticais Wize em `src/method-skills/1-analysis/`.
+- **D8.2 — Micro-file architecture:** workflows substituídos por step files auto-contidos em `steps/` ou `{vertical}-steps/`. Cada step controla frontmatter `stepsCompleted` e só avança com confirmação do usuário.
+- **D8.3 — Manter dispatcher genérico:** `wize-research` continua existindo como skill genérico, mas as três vertentes oferecem passos estruturados e templates próprios.
+- **D8.4 — Versionamento dos workflows antigos:** cópias dos `workflow.md` monolíticos de `wize-create-architecture` e `wize-code-review` são arquivadas em `.wize/knowledge/decisions/` para referência, não mantidas em produção.
+- **D8.5 — Registro em catálogos:** skills adicionados a `src/core-skills/module.yaml` e `src/method-skills/module.yaml`; fluxos refletidos no `README.md`.
+
+### Fase 9 — Security Overlay + OpenCode nativo (2026-07-11)
+
+- **D9.1 — Security Overlay neste kit:** o perfil `security-overlay` (AI Pentester) passa a ser distribuído **dentro do `wize-dev-kit`** como 4º perfil opt-in do installer, com a persona **red-teamer** (`wize-sec-red-teamer`) em `src/security-overlay/`. _Supersede parcialmente D1.1 (3 perfis → 4 perfis), D3.2 (9 papéis → 9 core + 1 overlay) e D3.5 (security deixava de ser reservado para kit futuro)._ As entradas históricas permanecem inalteradas como registro.
+- **D9.2 — OpenCode com wiring nativo (0.8.0):** o adapter OpenCode passa a gerar **agents e commands nativos** (`.opencode/agents/` + `.opencode/commands/`), com commands vinculados à persona dona e workers de fan-out isolados — em vez do fallback genérico.
+
+### Fase 10 — Mission contracts, grill, loop e polish (2026-08)
+
+- **D10.1 — Mission contracts (0.9.0):** cada etapa da cadeia passa a operar por um contrato explícito (objetivo, fontes de verdade, escopo & limites, ACs, contratos de execução/validação, persistência em `.wize/`). `/wize-help mission` emite o contrato preenchido a partir do estado do projeto; templates de story ganham campos de contrato (sources of truth, restrictions, validation, done-means). Motivo: modelos de longo horizonte executam melhor com o alvo declarado.
+- **D10.2 — `wize-grill` (0.10.0):** nova skill core de entrevista-até-entendimento antes de qualquer passo de autoria (brief, PRD, epics, stories, planos). Sempre sugestiva, nunca imposta; sem artefato próprio (decisões caem nos campos do artefato alvo). Adaptado do princípio grill-me.
+- **D10.3 — Loop verification + max-cycles guard (0.10.0):** `wize-dev-story` ganha auto-check antes de declarar o loop concluído (evidência de iteração, mapa AC→teste completo, testes verdes) e guarda de ciclo (mesmo AC falhando 3+ vezes → escala para `wize-correct-course`, agora também auto-disparado).
+- **D10.4 — Persona do overlay ganha nome Marvel:** o `red-teamer` passa a ter o nome de exibição **Natasha Romanoff** (espionagem/operação ofensiva sob mandato — casa com o scope-gate do overlay). Mudança **apenas de nome de exibição**: o `code` permanece `wize-sec-red-teamer` (identificador de invocação e diretório dos 9 adapters, estável). "Red-Teamer" fica no `title`. _Deadpool foi avaliado e rejeitado: o nome entra no corpo do SKILL.md como instrução e o personagem é o que mais ignora autorização — conflita com o design de consentimento do overlay._ Remove Black Widow do pool de personas reservadas no `ROSTER.md`.
+- **D10.5 — Correções de tooling/qualidade:** (a) `readYamlField` passa a ler **block scalars** (`description: |`) — antes toda descrição renderizada terminava em `— |` nos 9 adapters; (b) `npm test` deixa de usar glob não-recursivo e passa a rodar também `test/security-overlay/**` (evita 8 testes stale passarem despercebidos); (c) adicionado workflow de **CI** (`ci.yml`) em push/PR (Node 20+24), já que só existia `publish.yml` por tag; (d) roster do `AGENTS.md` gerado passa a ser ordenado deterministicamente e marca a persona opt-in do overlay.
+
 ## Perguntas em aberto
 
 _(serão preenchidas conforme a entrevista avança)_
+

package/README.es.md

@@ -0,0 +1,296 @@
+# Wize Development Kit
+
+> **Kit de desarrollo asistido por IA, de ciclo completo** — lleva un proyecto del brief a la implementación testeada mediante 10 agentes especializados, con un Test Architect, un estudio de UX Whiteport y un Pentester de IA integrados. Funciona dentro de tu IDE con IA.
+
+[![npm version](https://img.shields.io/npm/v/wize-dev-kit?color=blue)](https://www.npmjs.com/package/wize-dev-kit)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Status](https://img.shields.io/badge/status-beta-green)](#estado)
+[![Repo](https://img.shields.io/badge/repo-qwize--br%2Fwize--development--kit-181717?logo=github)](https://github.com/qwize-br/wize-development-kit)
+
+**🌐 Idiomas:** [English](README.md) · [Português (pt-BR)](README.pt-BR.md) · **Español**
+
+---
+
+## Resumen rápido
+
+```bash
+npx wize-dev-kit install
+```
+
+Elige tus perfiles y tu IDE; luego, en tu IDE con IA, di *"Activa a Wizer y dale el briefing del proyecto."* Wizer te guía por el agente adecuado en cada fase — brief, PRD, UX, arquitectura, código testeado — y (opcionalmente) ejecuta un pentest de IA sobre tu aplicación.
+
+---
+
+## Qué es
+
+Wize Development Kit (WDK) es un **stack de agentes de IA** instalable que funciona dentro de tu IDE con IA (Claude Code, Cursor, Windsurf, Codex y otros) y escribe artefactos estructurados en una carpeta oculta `.wize/` de tu repositorio. Lleva un proyecto de **brief → PRD → estrategia de UX → arquitectura → implementación testeada**, y también puede **hacer pentest de la app en ejecución y planificar el sprint de remediación**.
+
+Es **file-first y zero-runtime**: los agentes son skills en Markdown que tu IDE lee; el tooling es Node puro (una única dependencia npm — `prompts`, usada solo por el instalador; nada se añade a tu proyecto). Nada está simulado — cada paso lee el artefacto anterior y escribe uno real.
+
+### Perfiles (combinables en monorepos)
+
+| Perfil | Qué añade |
+|---|---|
+| **Wize Dev Core** | Ciclo completo (análisis → plan → solución → implementación) + Test Architect + UX Whiteport + Agent Builder. Siempre instalado. |
+| **Wize Web Dev** *(overlay)* | Scaffolds web, SEO, analytics, playbook WCAG para Mantis, Playwright/Vitest para Hawkeye. |
+| **Wize App Development** *(overlay)* | Scaffolds móviles, ficha de tienda, directrices de plataforma (HIG / Material 3), Detox/Maestro para Hawkeye. |
+| **Wize Security** *(overlay)* | **Pentester de IA.** Pipeline de pentest file-first (recon → enumerate → SAST → DAST → report) conducido por **Natasha Romanoff**, la persona `red-teamer`, con gate de alcance, clasificación OWASP/CVSS e informe ejecutivo. |
+
+---
+
+## Instalación
+
+En cualquier repositorio, nuevo o existente (greenfield o brownfield):
+
+```bash
+npx wize-dev-kit install
+```
+
+O directamente desde GitHub (sin necesidad de npm):
+
+```bash
+npx github:qwize-br/wize-development-kit install
+```
+
+El instalador pregunta:
+
+1. **Nombre del proyecto** — escrito en `.wize/config/project.toml`.
+2. **Perfil(es)** — Core / +Web / +App / +Security (selección múltiple).
+3. **IDE(s) objetivo** — Claude Code, Cursor, Windsurf, Codex, Continue, Kimi Code, Hermes, Kiro, OpenCode, Antigravity o fallback genérico (selección múltiple).
+4. **Idiomas** — comunicación + salida de documentos.
+5. **Tu nombre** — cómo deben dirigirse a ti los agentes (guardado en `user.toml`).
+6. **Brownfield** — ofrece ejecutar `wize-document-project` para crear la baseline del código existente.
+
+Tras instalar, abre tu IDE y di:
+
+> "Activa a Wizer y dale el briefing del proyecto."
+
+---
+
+## Harnesses soportados
+
+Los 11 IDEs objetivo se renderizan desde la misma fuente; el formato y la mecánica varían por harness. **OpenCode** recibe la integración más profunda — la separación persona/workflow del kit se mapea sobre las primitivas propias de OpenCode (`mode: primary|subagent`, `agent:`, `subtask:`) en lugar de aplanarse en un único tipo de archivo.
+
+| Harness | Salida | Destacado |
+|---|---|---|
+| **OpenCode** 🆕 | `.opencode/agents/` + `.opencode/commands/` | `mode: primary\|subagent` nativo; los comandos se vinculan automáticamente a su persona propietaria (`agent:`); los workers de fan-out corren aislados (`subtask: true`). [Docs →](docs/harnesses/opencode.md) |
+| **Claude Code** | `.claude/skills/*/SKILL.md` | Formato Skill de Anthropic; fan-out ad-hoc vía Task/Agent tool (`wize-code-review`). [Docs →](docs/harnesses/claude-code.md) |
+| **Codex** | `.agents/skills/*/SKILL.md` | Mismo formato Skill + `AGENTS.md` en la raíz. [Docs →](docs/harnesses/codex.md) |
+| **Kimi Code** | `.kimi/skills/*/SKILL.md` | Mismo formato Skill; autodetecta árboles de skills de Claude/Codex. [Docs →](docs/harnesses/kimi-code.md) |
+| **Hermes Agent** 🆕 | `.hermes/skills/*/SKILL.md` | Mismo formato Skill, project-local; trust gate (`hermes skills trust`); las skills del proyecto sobreescriben las de perfil. [Docs →](docs/harnesses/hermes.md) |
+| **Kiro — AWS** 🆕 | `.kiro/skills/*/SKILL.md` | Estándar Agent Skills (agentskills.io); las skills de workspace sobrescriben las globales; activación automática por descripción, o `/wize-{code}`. [Docs →](docs/harnesses/kiro.md) |
+| **Antigravity** | `.agent/skills/*/SKILL.md` | Mismo formato Skill + `AGENTS.md` en la raíz. [Docs →](docs/harnesses/antigravity.md) |
+| **Cursor** | `.cursor/rules/*.mdc` | Reglas on-demand (`alwaysApply: false`), emparejadas por descripción. [Docs →](docs/harnesses/cursor.md) |
+| **Windsurf** | `.windsurf/rules/*.md` | Markdown plano; el modo de activación se define dentro del IDE. [Docs →](docs/harnesses/windsurf.md) |
+| **Continue.dev** | `.continue/prompts/*.prompt` | Slash commands con `invokable: true`. [Docs →](docs/harnesses/continue.md) |
+| **Fallback genérico** | `.wize/agents/*.md` + `AGENTS.md` en la raíz | Para cualquier IDE sin adapter dedicado. [Docs →](docs/harnesses/generic.md) |
+
+---
+
+## El elenco
+
+| # | Persona | Código | Rol |
+|---|---|---|---|
+| 1 | **Wizer** | `wize-orchestrator` | Orquestador, base de conocimiento, briefing, enrutamiento |
+| 2 | **Pepper Potts** | `wize-agent-analyst` | Analista de Negocio + WDS Saga (brief de producto, trigger map) |
+| 3 | **Peggy Carter** | `wize-agent-tech-writer` | Redactora Técnica (transversal) |
+| 4 | **Maria Hill** | `wize-agent-pm` | Product Manager (PRD, epics, sprints) |
+| 5 | **Mantis** | `wize-agent-ux-designer` | UX Designer + WDS Freya (escenarios, diseño, design system) |
+| 6 | **Nick Fury** | `wize-agent-solution-strategist` | Estrategia de Solución, visión técnica, principios de NFR |
+| 7 | **Tony Stark** | `wize-agent-architect` | Arquitecto de Sistemas (arquitectura, ADRs, epics, stories) |
+| 8 | **Hawkeye** | `wize-agent-test-architect` | Test Architect — 6 gates (risk, design, trace, nfr, review, gate) |
+| 9 | **Shuri** | `wize-agent-dev` | Desarrolladora Senior (TDD, código, refactor) |
+| 10 | **Natasha Romanoff** | `wize-sec-red-teamer` (overlay de seguridad) | Red-Teamer / Pentester de IA — recon, SAST/DAST, pruebas ofensivas con alcance, informe |
+
+Consulta [`ROSTER.md`](ROSTER.md) para personas, estilos y equivalencias con BMAD.
+
+---
+
+## Recorrido — un proyecto completo, de principio a fin
+
+Cada paso es un slash command en tu IDE; cada persona lee el artefacto anterior antes de escribir el suyo.
+
+```
+1.  /wize-orchestrator          Wizer saluda, lee config, detecta el estado y enruta.
+
+2.  /wize-grill                  Cualquier persona te entrevista hasta un entendimiento
+                                compartido antes de redactar — una pregunta a la vez,
+                                cada una con respuesta recomendada (ofrecida, nunca
+                                impuesta).
+    /wize-product-brief         Pepper convierte la demanda bruta en brief.md.
+    /wize-trigger-map           Pepper mapea psicología del usuario → metas de negocio (WDS).
+    /wize-research              Pepper sintetiza evidencia externa (opcional).
+
+3.  /wize-create-prd            Maria Hill escribe prd.md (metas, alcance, ACs).
+    /wize-validate-prd          Maria Hill (+ Mantis/Fury) aprueba.
+
+4.  /wize-ux-scenarios          Mantis conduce el diálogo WDS de 8 preguntas.
+    /wize-ux-design             Mantis escribe specs de pantalla (un .md por pantalla).
+
+5.  /wize-tech-vision           Fury elige la familia de stack + innegociables.
+    /wize-nfr-principles        Fury escribe el presupuesto de NFR (perf, seg, a11y…).
+
+6.  /wize-create-architecture   Tony escribe architecture.md + ADRs (8 pasos).
+    /wize-design-system         Mantis escribe design-system/ (tokens + componentes).
+    /wize-create-epics-and-stories
+                                Tony divide epics → stories (cada una con ACs).
+
+7.  /wize-sprint-planning       Maria Hill abre el sprint desde los epics/stories.
+    /wize-tea-risk              Hawkeye construye el perfil global de riesgo.
+    /wize-tea-design            Hawkeye escribe el test design de la próxima story.
+    /wize-create-story          Tony escribe la siguiente story con los campos de
+                                contrato: fuentes de verdad, restricciones,
+                                validación, done-means.
+    /wize-dev-story             Shuri implementa (TDD, IDs de AC en los commits) con
+                                loop auto-verificable y guarda de 3 ciclos.
+    /wize-tea-trace             Hawkeye mapea cada AC → tests.
+    /wize-tea-review            Hawkeye ejecuta la revisión de la story.
+    /wize-tea-gate              Hawkeye emite PASS / CONCERNS / FAIL / WAIVED.
+
+8.  /wize-sprint-status         Maria Hill mantiene el snapshot diario actualizado.
+    /wize-retrospective         Wizer facilita la retro al final de cada sprint.
+
+Transversales:
+    /wize-help                  Wizer te enruta: `next` (única acción siguiente),
+                                `status` (snapshot del proyecto), `mission` (un
+                                contrato de misión lleno para la persona ejecutora).
+    /wize-check                 Checklist de avance de la demanda en vuelo: hecho
+                                (con evidencia), en curso, lo que falta — luego
+                                retoma el trabajo interrumpido.
+    /wize-grill                 Entrevista-hasta-entendimiento antes de cualquier
+                                paso de autoría.
+    /wize-quick-dev             Shuri toma un arreglo pequeño sin el ciclo completo.
+    /wize-pre-pr-check          Corre lint/format/build/tests unitarios localmente
+                                antes de abrir un PR — falla rápido, cero costo de runner.
+    /wize-correct-course        Re-planifica cuando un gate falla o el loop se
+                                estanca (auto-disparado por la guarda de max-cycles;
+                                también manual).
+    /wize-code-review           Revisión adversarial antes del gate TEA de Hawkeye.
+    /wize-party-mode            Wizer reúne multi-persona para decisiones difíciles.
+```
+
+> Usa `/wize-help next` cuando tengas dudas — inspecciona `.wize/` y te dice la única acción siguiente.
+
+---
+
+## 🛡️ Overlay de seguridad — Pentester de IA
+
+Con el perfil **Wize Security** instalado, **Natasha Romanoff** (`wize-sec-red-teamer`, la persona red-teamer) ejecuta un pentest file-first de tu proyecto y produce un informe listo para stakeholders.
+
+### Cómo funciona
+
+1. **Autoriza el objetivo.** Declaras hosts/URLs permitidos en un `.wize/security/scope.md` firmado (integridad por SHA-256). Cualquier cosa fuera de la allowlist es **rechazada y auditada** — la herramienta nunca toca un objetivo que no autorizaste.
+2. **Ejecuta el pipeline.**
+   ```
+   /wize-sec-pentest                 # pasivo por defecto (chequeos read-only)
+   /wize-sec-pentest --active        # habilita tooling ofensivo (sqlmap, ffuf)
+   ```
+   Encadena: **recon** (nmap) → **enumerate** (superficie HTTP) → **SAST** (secrets con gitleaks + deps con osv-scanner/grype) → **DAST** (nuclei, nikto, sqlmap, ffuf) → **report**.
+3. **Lee el informe.** `report.md` + un `report.html` self-contained (offline, WCAG 2.2 AA) con:
+   - **Puntuación de riesgo 0–100** + **briefing** ejecutivo (qué significa el riesgo para el negocio),
+   - hallazgos clasificados por **CVSS v3.1** y **OWASP Top 10**, con secrets redactados,
+   - **cobertura honesta** ("audit confidence" — qué se probó y qué no),
+   - un **plan de acción priorizado** (P0/P1/P2).
+4. **Planifica la corrección.** El scan genera `security-backlog.md` (epics de remediación agrupados por tema, trazables a los hallazgos) e imprime el comando exacto para convertirlo en un sprint:
+   ```
+   /wize-create-epics-and-stories --from .wize/security/security-backlog.md
+   ```
+
+### Garantías de diseño
+
+- **Cero runtime propio** — solo built-ins de Node; ninguna dependencia npm nueva; el overlay nunca invoca una skill (imprime el comando para que tú/el agente lo ejecuten).
+- **Los datos quedan locales** — informes y hallazgos se escriben en `.wize/security/`, nunca se suben a ningún lado.
+- **Las herramientas se detectan, nunca se auto-instalan** — un preflight comprueba tu toolchain y genera un `install-pentest-tools.sh` consciente del SO (apt para nmap/nikto/sqlmap; releases de GitHub para gitleaks/nuclei/ffuf/osv-scanner; script oficial para grype). Una herramienta ausente degrada solo ese chequeo — el pipeline continúa.
+- **Pasivo por defecto** — el tooling ofensivo (sqlmap/ffuf) solo corre con `--active`; flags peligrosas (`--dump`, `--os-shell`) son vetadas por una allowlist independiente del input.
+
+> ⚠️ **Herramienta de doble uso.** Prueba solo sistemas que poseas o estés explícitamente autorizado a probar.
+
+---
+
+## Estructura de salida (en el repositorio objetivo)
+
+```
+.wize/
+├── config/             # project.toml, user.toml, tea.toml
+├── planning/           # brief, research, ux/, prd, tech-vision, nfr-principles
+├── solutioning/        # architecture, adrs, epics, stories
+├── implementation/     # sprint-status, retrospective, tea/{gates}
+├── knowledge/          # docs y referencias de larga duración
+├── security/           # scope.md, report.{md,html}, security-backlog.md (overlay de seguridad)
+└── custom/             # agents/skills/workflows creados por Agent Builder
+```
+
+---
+
+## Comandos de la CLI
+
+```bash
+npx wize-dev-kit install         # setup interactivo
+npx wize-dev-kit update          # actualiza un kit instalado a la versión actual
+npx wize-dev-kit sync            # re-renderiza los adapters de IDE tras editar la config
+npx wize-dev-kit list            # lista agentes, skills y workflows instalados
+npx wize-dev-kit agent list      # lista agentes nativos + personalizados
+npx wize-dev-kit agent create    # crea un nuevo agente personalizado (validado + dry-run)
+npx wize-dev-kit agent edit <code>  # sobrescribe un agente nativo
+npx wize-dev-kit workflow list   # lista workflows nativos + personalizados
+npx wize-dev-kit workflow create # crea un nuevo workflow personalizado
+npx wize-dev-kit doctor          # diagnostica kit / proyecto / adapters / gates
+npx wize-dev-kit validate        # chequeos estructurales en los assets del kit
+npx wize-dev-kit document-project [quick|initial_scan|full_rescan|deep_dive] [--resume] [--target <path>]
+npx wize-dev-kit uninstall       # elimina .wize/ (tu código queda intacto)
+npx wize-dev-kit help            # referencia de comandos
+npx wize-dev-kit version         # imprime la versión instalada del kit
+```
+
+---
+
+## Documentación
+
+- [`ARCH.md`](ARCH.md) — arquitectura completa: distribución, flujos, layout, instalador.
+- [`ROSTER.md`](ROSTER.md) — personas con estilo, rol, equivalencias BMAD.
+- [`AGENTS.md`](AGENTS.md) — el roster generado + el contexto operativo que las IDEs leen en la raíz del repo.
+- [`DECISIONS.md`](DECISIONS.md) — registro de decisiones.
+- [`CHANGELOG.md`](CHANGELOG.md) — historial de releases.
+- [`docs/harnesses/`](docs/harnesses/) — un doc por [harness soportado](#harnesses-soportados), en inglés + [pt-BR](README.pt-BR.md#harnesses-suportadas).
+
+---
+
+## Estado
+
+**v0.12.1 — beta.** El método nunca produce estimaciones de desarrollo — ni horas, ni puntos, ni tallas de camiseta; una story se dimensiona solo por si cabe en un único PR. El ciclo completo (análisis → plan → solución → implementación) está montado con 10 agentes y una biblioteca estructurada de skills. Los releases recientes suman **contratos de misión** (`/wize-help mission`), **`wize-grill`** (entrevista-hasta-entendimiento antes de cualquier paso de autoría), **`wize-pre-pr-check`** (gate local de lint/format/build/tests unitarios antes de abrir un PR — cero costo de runner de CI) y **loop verification** en `wize-dev-story` (un loop de implementación auto-verificable con guarda de max-cycles que escala a `wize-correct-course`). El `security-overlay` (Pentester de IA) entrega un pipeline de pentest completo, un informe ejecutivo (puntuación de riesgo + briefing + plan de acción por IA) y planificación de remediación post-scan — validado de principio a fin contra una aplicación Laravel/PHP real. Los adapters de IDE para Claude Code, Cursor, Windsurf, Codex, Continue, Kimi Code, Hermes, OpenCode y Antigravity se regeneran automáticamente — [OpenCode](docs/harnesses/opencode.md) recibe wiring nativo de `mode`/`agent`/`subtask`, la integración más profunda de las 10.
+
+---
+
+## Inspiración y créditos
+
+- [BMAD Method](https://github.com/bmad-code-org/BMAD-METHOD) por Brian (BMad) Madison — ciclo ágil de IA, personas de agentes, patrón de instalador, sistema de módulos.
+- [Whiteport Design Studio expansion](https://github.com/bmad-code-org/bmad-method-wds-expansion) — metodología UX-first, panteón nórdico (Saga, Freya), estructura de fases.
+
+Wize Development Kit es una **adaptación independiente** — no afiliada ni respaldada por los autores de BMAD o WDS. Los nombres de personas Marvel se usan como referencias creativas bajo uso nominativo justo.
+
+---
+
+## Licencia
+
+MIT — consulta [`LICENSE`](LICENSE).
+
+---
+
+## 🤖 Prerrequisito para colaborar con agentes de IA
+
+Antes de abrir este repo en cualquier agente (Claude Code, Cursor, Codex, Antigravity, OpenCode, Kimi, Qwen, …), instala el Wize Dev Kit:
+
+```bash
+npx wize-dev-kit@latest install
+```
+
+Por qué:
+
+- Inyecta las skills `/wize-*` (analista, PM, arquitecto, dev, TEA, orquestador) que le dan estructura al ciclo de vida del proyecto.
+- Crea/actualiza una baseline brownfield en `.wize/knowledge/document-project/` — la fuente canónica a consultar antes de decidir cambios.
+- Habilita el seguimiento de actividad en `.wize/implementation/` — cada story, plan y gate queda auditable.
+- Estandariza idiomas y quality gates entre agentes vía `.wize/config/`.
+
+Sin el kit, el agente trabaja sin contexto histórico, sin gates y sin trazabilidad. Esto vale para cualquier agente de IA usado en el proyecto.
+
+Para Claude Code: empieza con `/wize-help` para un diagnóstico y el siguiente paso recomendado.

package/README.md

@@ -56,7 +56,7 @@ The installer asks:
 
 1. **Project name** — written into `.wize/config/project.toml`.
 2. **Profile(s)** — Core / +Web / +App / +Security (multi-select).
-3. **IDE target(s)** — Claude Code, Cursor, Windsurf, Codex, Continue, Kimi Code, OpenCode, Antigravity, or generic fallback (multi-select).
+3. **IDE target(s)** — Claude Code, Cursor, Windsurf, Codex, Continue, Kimi Code, Hermes, Kiro, OpenCode, Antigravity, or generic fallback (multi-select).
 4. **Languages** — communication + document output.
 5. **Your name** — how the agents should address you (saved to `user.toml`).
 6. **Brownfield** — offers to run `wize-document-project` to baseline the existing codebase.
@@ -69,7 +69,7 @@ After install, open your IDE and say:
 
 ## Supported harnesses
 
-All 10 IDE targets render from the same source; format and mechanics differ per harness. **OpenCode** gets the deepest integration — the kit's persona/workflow split maps onto OpenCode's own primitives (`mode: primary|subagent`, `agent:`, `subtask:`) instead of being flattened into one file type.
+All 11 IDE targets render from the same source; format and mechanics differ per harness. **OpenCode** gets the deepest integration — the kit's persona/workflow split maps onto OpenCode's own primitives (`mode: primary|subagent`, `agent:`, `subtask:`) instead of being flattened into one file type.
 
 | Harness | Output | Notable |
 |---|---|---|
@@ -78,6 +78,7 @@ All 10 IDE targets render from the same source; format and mechanics differ per
 | **Codex** | `.agents/skills/*/SKILL.md` | Same Skill format + root `AGENTS.md`. [Docs →](docs/harnesses/codex.md) |
 | **Kimi Code** | `.kimi/skills/*/SKILL.md` | Same Skill format; auto-detects Claude/Codex skill trees. [Docs →](docs/harnesses/kimi-code.md) |
 | **Hermes Agent** 🆕 | `.hermes/skills/*/SKILL.md` | Same Skill format, project-local; trust gate (`hermes skills trust`); project skills override profile ones. [Docs →](docs/harnesses/hermes.md) |
+| **Kiro — AWS** 🆕 | `.kiro/skills/*/SKILL.md` | Agent Skills standard (agentskills.io); workspace skills override global ones; auto-activates by description, or `/wize-{code}`. [Docs →](docs/harnesses/kiro.md) |
 | **Antigravity** | `.agent/skills/*/SKILL.md` | Same Skill format + root `AGENTS.md`. [Docs →](docs/harnesses/antigravity.md) |
 | **Cursor** | `.cursor/rules/*.mdc` | On-demand rules (`alwaysApply: false`), matched by description. [Docs →](docs/harnesses/cursor.md) |
 | **Windsurf** | `.windsurf/rules/*.md` | Plain markdown; activation mode set inside the IDE. [Docs →](docs/harnesses/windsurf.md) |