wize-dev-kit 0.16.1 → 0.18.0

package/CHANGELOG.md

@@ -7,7 +7,21 @@ Format inspired by [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 > **0.10.0 and earlier are in Brazilian Portuguese** and are kept verbatim as a
 > historical record (not back-translated).
 
-## [Unreleased]
+## [0.18.0] — 2026-09-18
+
+### Added
+
+- **`wize-update`** (orchestrator skill) + **`wize-dev-kit version-check`** (CLI) — an agent-facing way to ask "is there a newer kit?" without hitting the network on every invocation. `version-check --json` reads a local 1h cache first, caps any registry call at ~1.5s, and degrades to `{"latest":null}` silently when offline; it honors `WIZE_DISABLE_UPDATE_CHECK=1` like the existing opportunistic hint. `wize-help`/`wize`'s proactive version-skew check (Step 2.5) now calls it instead of a live `npm view` on every invocation, says the hint at most once per conversation, and points to `/wize-update` — which shows the version jump + changelog excerpt, asks for a one-line confirmation, then runs `npx wize-dev-kit@latest update` and relays the result. Intent phrases: "atualizar o kit", "tem atualização", "nova versão do kit".
+
+## [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
 

package/README.es.md

@@ -56,7 +56,7 @@ 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, OpenCode, Antigravity o fallback genérico (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.
@@ -69,7 +69,7 @@ Tras instalar, abre tu IDE y di:
 
 ## Harnesses soportados
 
-Los 10 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.
+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 |
 |---|---|---|
@@ -78,6 +78,7 @@ Los 10 IDEs objetivo se renderizan desde la misma fuente; el formato y la mecán
 | **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) |
@@ -156,6 +157,8 @@ Transversales:
     /wize-check                 Checklist de avance de la demanda en vuelo: hecho
                                 (con evidencia), en curso, lo que falta — luego
                                 retoma el trabajo interrumpido.
+    /wize-update                Revisa si el kit está desactualizado, muestra el
+                                changelog, confirma y aplica la actualización.
     /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.
@@ -239,6 +242,7 @@ npx wize-dev-kit document-project [quick|initial_scan|full_rescan|deep_dive] [--
 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
+npx wize-dev-kit version-check [--json]  # instalada vs. más reciente (con caché; scriptable; nunca bloquea)
 ```
 
 ---

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) |
@@ -154,6 +155,8 @@ Cross-cutting:
     /wize-check                 Progress checklist for the demand in flight:
                                 done (with evidence), in progress, what's left —
                                 then resumes the interrupted work.
+    /wize-update                Checks kit version skew, shows the changelog
+                                jump, confirms, then applies the update.
     /wize-grill                 Interview-to-understanding before any authoring step.
     /wize-eli5                  Explain anything to anyone — vocabulary, analogies,
                                 tone, depth and framing calibrated to the audience
@@ -237,6 +240,7 @@ npx wize-dev-kit document-project [quick|initial_scan|full_rescan|deep_dive] [--
 npx wize-dev-kit uninstall       # remove .wize/ (your code is left untouched)
 npx wize-dev-kit help            # command reference
 npx wize-dev-kit version         # print the installed kit version
+npx wize-dev-kit version-check [--json]  # installed vs latest (cached; scriptable; never blocks)
 ```
 
 ---

package/README.pt-BR.md

@@ -56,7 +56,7 @@ O instalador pergunta:
 
 1. **Nome do projeto** — gravado em `.wize/config/project.toml`.
 2. **Perfil(is)** — Core / +Web / +App / +Security (múltipla escolha).
-3. **IDE(s) alvo** — Claude Code, Cursor, Windsurf, Codex, Continue, Kimi Code, OpenCode, Antigravity ou fallback genérico (múltipla escolha).
+3. **IDE(s) alvo** — Claude Code, Cursor, Windsurf, Codex, Continue, Kimi Code, Hermes, Kiro, OpenCode, Antigravity ou fallback genérico (múltipla escolha).
 4. **Idiomas** — comunicação + saída de documentos.
 5. **Seu nome** — como os agentes devem te chamar (salvo em `user.toml`).
 6. **Brownfield** — oferece rodar `wize-document-project` para criar a baseline do código existente.
@@ -69,7 +69,7 @@ Após instalar, abra sua IDE e diga:
 
 ## Harnesses suportadas
 
-Os 10 alvos de IDE são gerados a partir da mesma fonte; formato e mecânica mudam por harness. O **OpenCode** tem a integração mais profunda — a divisão persona/workflow do kit mapeia pras primitivas nativas do próprio OpenCode (`mode: primary|subagent`, `agent:`, `subtask:`) em vez de ser achatada num único tipo de arquivo.
+Os 11 alvos de IDE são gerados a partir da mesma fonte; formato e mecânica mudam por harness. O **OpenCode** tem a integração mais profunda — a divisão persona/workflow do kit mapeia pras primitivas nativas do próprio OpenCode (`mode: primary|subagent`, `agent:`, `subtask:`) em vez de ser achatada num único tipo de arquivo.
 
 | Harness | Saída | Destaque |
 |---|---|---|
@@ -78,6 +78,7 @@ Os 10 alvos de IDE são gerados a partir da mesma fonte; formato e mecânica mud
 | **Codex** | `.agents/skills/*/SKILL.md` | Mesmo formato Skill + `AGENTS.md` na raiz. [Docs →](docs/harnesses/codex.pt-BR.md) |
 | **Kimi Code** | `.kimi/skills/*/SKILL.md` | Mesmo formato Skill; autodetecta as árvores do Claude/Codex. [Docs →](docs/harnesses/kimi-code.pt-BR.md) |
 | **Hermes Agent** 🆕 | `.hermes/skills/*/SKILL.md` | Mesmo formato Skill, project-local; trust gate (`hermes skills trust`); skills do projeto sobrescrevem as de perfil. [Docs →](docs/harnesses/hermes.pt-BR.md) |
+| **Kiro — AWS** 🆕 | `.kiro/skills/*/SKILL.md` | Padrão Agent Skills (agentskills.io); skills de workspace sobrescrevem as globais; ativação automática por descrição, ou `/wize-{code}`. [Docs →](docs/harnesses/kiro.pt-BR.md) |
 | **Antigravity** | `.agent/skills/*/SKILL.md` | Mesmo formato Skill + `AGENTS.md` na raiz. [Docs →](docs/harnesses/antigravity.pt-BR.md) |
 | **Cursor** | `.cursor/rules/*.mdc` | Rules sob demanda (`alwaysApply: false`), casadas por descrição. [Docs →](docs/harnesses/cursor.pt-BR.md) |
 | **Windsurf** | `.windsurf/rules/*.md` | Markdown puro; modo de ativação definido dentro da IDE. [Docs →](docs/harnesses/windsurf.pt-BR.md) |
@@ -155,6 +156,8 @@ Transversais:
     /wize-check                 Checklist de acompanhamento da demanda em voo:
                                 feito (com evidência), em andamento, o que falta —
                                 depois retoma o trabalho interrompido.
+    /wize-update                Verifica se o kit está desatualizado, mostra o
+                                changelog, confirma e aplica o update.
     /wize-grill                 Entrevista-até-entendimento antes de qualquer passo
                                 de autoria.
     /wize-quick-dev             Shuri pega uma correção pequena sem o ciclo completo.
@@ -237,6 +240,7 @@ npx wize-dev-kit document-project [quick|initial_scan|full_rescan|deep_dive] [--
 npx wize-dev-kit uninstall       # remove .wize/ (seu código permanece intacto)
 npx wize-dev-kit help            # referência de comandos
 npx wize-dev-kit version         # imprime a versão instalada do kit
+npx wize-dev-kit version-check [--json]  # instalada vs. mais recente (com cache; scriptável; nunca bloqueia)
 ```
 
 ---

package/adapters/README.md

@@ -13,6 +13,7 @@ Each adapter renders the kit's agents/skills/workflows into the file layout that
 | `continue` | `.continue/prompts/wize-*.prompt` | `.prompt` | Continue prompt slot. |
 | `kimi-code` | `.kimi/skills/wize-*/` | `SKILL.md` per agent/workflow | Moonshot Kimi Code. |
 | `hermes` | `.hermes/skills/wize-*/` | `SKILL.md` per agent/workflow | Hermes Agent (project-local skills, Anthropic-compatible). |
+| `kiro` | `.kiro/skills/wize-*/` | `SKILL.md` per agent/workflow | Kiro (AWS) — Agent Skills standard (agentskills.io), workspace scope. |
 | `opencode` | `.opencode/agents/wize-*.md` + `.opencode/commands/wize-*.md` | Markdown | OpenCode CLI. Native agents + commands. |
 | `antigravity` | `.agent/skills/wize-*/` | `SKILL.md` per agent/workflow | Antigravity CLI + IDE. |
 | `generic` | `.wize/agents/wize-*.md` | Markdown | Fallback for any agent that can read a folder of markdown. |

package/adapters/kiro/README.md

@@ -0,0 +1,30 @@
+# Kiro (AWS) — Wize Dev Kit Adapter
+
+Emits the kit's agents/skills/workflows as Kiro workspace skills under
+`.kiro/skills/wize-{code}/SKILL.md`, using the open Agent Skills standard
+(agentskills.io) — a folder with a `SKILL.md` (YAML frontmatter: `name`,
+`description`), the same Anthropic-compatible format the kit already renders
+for Claude Code / Codex / Kimi Code / Hermes.
+
+## How Kiro picks these up
+
+- The default agent automatically loads workspace skills from
+  `<repo-root>/.kiro/skills/` and global skills from `~/.kiro/skills/`.
+  **Workspace skills win** on name collisions.
+- **Progressive disclosure:** at session start Kiro loads only `name` +
+  `description`; the full SKILL.md activates when your request matches the
+  description, or explicitly via `/wize-{code}` in chat.
+- **Activation is description-driven** (no config needed): keep descriptions
+  keyword-rich — the kit's descriptions already follow that guidance.
+- Skills must be valid frontmatter (`name` matches the folder name, lowercase
+  + hyphens, ≤ 64 chars; `description` ≤ 1024 chars) — the shared emitter
+  already guarantees this shape.
+- Kiro also reads `.kiro/steering/*.md` for always-on project context, so
+  pairing with the **Generic fallback** target (root `AGENTS.md`) is a bonus.
+- **Custom agents caveat:** Kiro custom agents don't load skills by default —
+  add `"skill://.kiro/skills/*/SKILL.md"` to the agent's `resources` field.
+
+## Files
+
+- `render.js` — renders via the shared `renderAnthropicSkills` emitter.
+- `adapter.yaml` — descriptor (target path, file pattern).

package/adapters/kiro/adapter.yaml

@@ -0,0 +1,8 @@
+code: kiro
+description: "Kiro (AWS) workspace skills (.kiro/skills/, Agent Skills standard, project-local)."
+target_path: ".kiro/skills/"
+file_pattern: "wize-*/SKILL.md"
+file_format: markdown
+hooks:
+  pre_render: []
+  post_render: []

package/adapters/kiro/render.js

@@ -0,0 +1,21 @@
+// Kiro (AWS) adapter — emits .kiro/skills/wize-{code}/SKILL.md per asset.
+// Kiro follows the open Agent Skills standard (agentskills.io): a skill is a
+// folder containing a SKILL.md with YAML frontmatter (name, description) —
+// the same Anthropic-compatible format used by Claude Code, Codex, Kimi Code,
+// and Hermes. Workspace skills live at <repo-root>/.kiro/skills/ and take
+// precedence over ~/.kiro/skills/ global skills on name collision. Kiro uses
+// progressive disclosure: at session start only name + description load, and
+// the full SKILL.md activates when the request matches the description (or
+// via the skill's slash command).
+
+'use strict';
+
+const path = require('node:path');
+const { renderAnthropicSkills } = require('../../tools/installer/render-shared.js');
+
+function render(kitRoot, projectRoot, opts = {}) {
+  const targetDir = path.join(projectRoot, '.kiro', 'skills');
+  return renderAnthropicSkills(kitRoot, targetDir, opts);
+}
+
+module.exports = { render };

package/docs/harnesses/kiro.md

@@ -0,0 +1,26 @@
+# Kiro (AWS) — Wize Development Kit
+
+🌐 **Languages:** **English** · [Português (pt-BR)](kiro.pt-BR.md)
+
+← [Back to README](../../README.md)
+
+Kiro, the agentic IDE/CLI from AWS, follows the open [Agent Skills standard](https://agentskills.io) — the same folder + `SKILL.md` (YAML frontmatter: `name`, `description`) shape the kit already renders for Claude Code, Codex, Kimi Code, and Hermes.
+
+## Output
+
+`.kiro/skills/wize-{code}/SKILL.md` — one directory per persona, workflow, or skill, with companion files (`steps/`, `templates/`, `data/`) copied alongside.
+
+## Notable
+
+- **Workspace scope.** Kiro's default agent automatically loads workspace skills from `<repo-root>/.kiro/skills/` and global skills from `~/.kiro/skills/`; **workspace skills win** on name collisions. Generated `wize-*` entries are gitignored (regenerate with `npx wize-dev-kit sync`) — hand-written team skills you add next to them should be committed, per Kiro's own guidance.
+- **Progressive disclosure.** At session start Kiro loads only each skill's `name` + `description`; the full `SKILL.md` activates when your request matches the description, or explicitly via `/wize-{code}` in chat. The kit's descriptions are written keyword-rich for exactly this match.
+- **Steering is separate.** Always-on project context lives in `.kiro/steering/*.md` — Kiro-specific and not produced by this adapter, so pairing with the **Generic fallback** target (root `AGENTS.md`) is a bonus.
+- **Custom agents caveat.** Kiro custom agents don't load skills by default — add `"skill://.kiro/skills/*/SKILL.md"` to the agent's `resources` field.
+
+## Setup
+
+Pick **Kiro — AWS** as an IDE target during `npx wize-dev-kit install` (or add it and re-run `npx wize-dev-kit sync`). Restart Kiro, then run `/wize-orchestrator`.
+
+## Headless
+
+`kiro-cli chat --no-interactive --trust-all-tools "<prompt>"` runs a one-shot headless session (requires `KIRO_API_KEY`), which the installer's brownfield baseline uses when Kiro CLI is the detected harness.

package/docs/harnesses/kiro.pt-BR.md

@@ -0,0 +1,26 @@
+# Kiro (AWS) — Wize Development Kit
+
+🌐 **Idiomas:** [English](kiro.md) · **Português (pt-BR)**
+
+← [Voltar ao README](../../README.pt-BR.md)
+
+O Kiro, IDE/CLI agêntica da AWS, segue o padrão aberto [Agent Skills](https://agentskills.io) — a mesma forma de pasta + `SKILL.md` (frontmatter YAML: `name`, `description`) que o kit já renderiza para Claude Code, Codex, Kimi Code e Hermes.
+
+## Saída
+
+`.kiro/skills/wize-{code}/SKILL.md` — um diretório por persona, workflow ou skill, com arquivos complementares (`steps/`, `templates/`, `data/`) copiados junto.
+
+## Destaques
+
+- **Escopo workspace.** O agente padrão do Kiro carrega automaticamente skills de workspace de `<repo-root>/.kiro/skills/` e skills globais de `~/.kiro/skills/`; **skills de workspace vencem** em colisões de nome. As entradas `wize-*` geradas ficam no .gitignore (regenere com `npx wize-dev-kit sync`) — skills de time escritas à mão, ao lado delas, devem ser commitadas, conforme a própria orientação do Kiro.
+- **Progressive disclosure.** No início da sessão o Kiro carrega apenas `name` + `description` de cada skill; o `SKILL.md` completo é ativado quando o pedido combina com a descrição, ou explicitamente via `/wize-{code}` no chat. As descrições do kit são escritas ricas em palavras-chave exatamente para esse match.
+- **Steering é separado.** Contexto de projeto sempre-on vive em `.kiro/steering/*.md` — específico do Kiro e não produzido por este adapter, então combinar com o alvo **Fallback genérico** (raiz `AGENTS.md`) é um bônus.
+- **Ressalva de custom agents.** Custom agents do Kiro não carregam skills por padrão — adicione `"skill://.kiro/skills/*/SKILL.md"` ao campo `resources` do agente.
+
+## Como ativar
+
+Escolha **Kiro — AWS** como alvo de IDE em `npx wize-dev-kit install` (ou adicione depois e rode `npx wize-dev-kit sync`). Reinicie o Kiro e rode `/wize-orchestrator`.
+
+## Headless
+
+`kiro-cli chat --no-interactive --trust-all-tools "<prompt>"` roda uma sessão headless de uma execução (requer `KIRO_API_KEY`), usada pelo baseline brownfield do instalador quando o Kiro CLI é o harness detectado.

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "wize-dev-kit",
-  "version": "0.16.1",
+  "version": "0.18.0",
   "description": "Full-lifecycle AI-assisted development kit with Test Architect and Whiteport Design Studio embedded. Inspired by BMAD Method and WDS.",
   "keywords": [
     "ai",

package/src/orchestrator-skills/module.yaml

@@ -22,6 +22,9 @@ skills:
   - code: wize-check
     name: "Check (Wizer)"
     description: "Progress checklist for the demand in flight: done (with evidence), in progress, left, blocked. Read-only — reports, then resumes the interrupted work."
+  - code: wize-update
+    name: "Update (Wizer)"
+    description: "Checks kit version skew, shows the changelog jump, confirms, then applies `wize-dev-kit update` and reports the result."
   - code: wize-onboarding
     name: "Onboarding"
     description: "Post-install triage: greenfield vs brownfield, profile, objective. Delegates to specialists."

package/src/orchestrator-skills/wize/skill.md

@@ -99,15 +99,15 @@ See the full intent routing table in `wize-help/skill.md` (Step 2a). The same ta
 
 ## Step 2.5 — version skew (proactive)
 
-Compare `kit_version` (project.toml) vs the installed kit vs (if you have a terminal, 2s timeout) `npm view wize-dev-kit version`:
+If you have Bash, run `npx wize-dev-kit version-check --json` once — it reads a local 1h cache before touching the network, caps any registry call at ~1.5s, and degrades to `{"latest":null}` silently if offline, so this never blocks the response. Compare its `installed` field against `kit_version` (project.toml):
 
 | Condition | Suggest |
 |---|---|
-| installed > project.toml | `npx wize-dev-kit update` |
-| registry > installed | `npx wize-dev-kit@latest update` |
-| all match | nothing |
+| `installed` > `kit_version` (project.toml) | `/wize-update` |
+| `latest` > `installed` | `/wize-update` |
+| everything matches, or `latest` is `null` | nothing |
 
-Phrase as one short line, not a banner. If the user agrees and you have Bash, run it in the project root.
+Phrase as one short line, not a banner — and only the **first time in this conversation**. If you already mentioned it earlier in this session, don't repeat it.
 
 ## Step 3 — respond
 

package/src/orchestrator-skills/wize-help/skill.md

@@ -201,18 +201,19 @@ Match is case-insensitive, substring-based. Longest match wins. When no intent m
 | "create workflow", "criar workflow", "novo workflow" | `wize-create-workflow` |
 | "onboarding", "instalar kit", "primeiro uso" | `wize-onboarding` |
 | "party mode", "multi-agent", "reunir agentes" | `wize-party-mode` |
+| "atualizar o kit", "tem atualização", "nova versão do kit", "update the kit", "wize update" | `wize-update` |
 
 ## Step 2.5 — version skew (proactive)
 
-Compare `kit_version` (project.toml) vs the installed kit vs (if you have a terminal, 2s timeout) `npm view wize-dev-kit version`:
+If you have Bash, run `npx wize-dev-kit version-check --json` once — it reads a local 1h cache before touching the network, caps any registry call at ~1.5s, and degrades to `{"latest":null}` silently if offline, so this never blocks the response. Compare its `installed` field against `kit_version` (project.toml):
 
 | Condition | Suggest |
 |---|---|
-| installed > project.toml | `npx wize-dev-kit update` |
-| registry > installed | `npx wize-dev-kit@latest update` |
-| all match | nothing |
+| `installed` > `kit_version` (project.toml) | `/wize-update` |
+| `latest` > `installed` | `/wize-update` |
+| everything matches, or `latest` is `null` | nothing |
 
-Phrase as one short line, not a banner. If the user agrees and you have Bash, run it in the project root.
+Phrase as one short line, not a banner — and only the **first time in this conversation**. If you already mentioned it earlier in this session, don't repeat it.
 
 ## Step 3 — respond
 

package/src/orchestrator-skills/wize-update/skill.md

@@ -0,0 +1,61 @@
+---
+
+code: wize-update
+description: "Use quando o usuário pedir para atualizar o Wize Dev Kit, perguntar se há uma versão nova, ou quando o Wizer notar version skew (Step 2.5) e ele confirmar o update."
+name: Update (Wizer)
+module: orchestrator
+owner: wize-orchestrator
+status: ready
+aliases: []
+---
+
+# Wizer · `/wize-update`
+
+**Goal.** Bring the installed kit up to date safely: check the real version skew, show what changes before anything runs, get a one-line confirmation, apply it, report the result. Never a surprise — this rewrites files under version control.
+
+## Step 1 — check version skew
+
+If you have Bash, run:
+
+```
+npx wize-dev-kit version-check --json
+```
+
+Cheap by design: it reads a local 1h cache before touching the network, caps any registry call at ~1.5s, and degrades to `{"latest":null}` silently if offline — it never blocks this step.
+
+Read `kit_version` from `.wize/config/project.toml` — that is the version **this project's** rendered skills are on. `version-check`'s `installed` field is the kit version currently resolved by `npx` (it can already be newer than what is rendered here, if someone bumped the resolved package without running `update`).
+
+| Condition | Meaning |
+|---|---|
+| `latest` (registry) > `installed` | A newer kit exists upstream. |
+| `installed` > project's `kit_version` | This project is behind what npx already resolves. |
+| everything matches, or `latest` is `null` | Nothing to do — say so in one line and stop. Do not continue to Step 2. |
+
+## Step 2 — show the jump, then confirm
+
+State the version jump plainly (`{from} → {to}`). If you have Bash, `sed -n`/`cat` the relevant excerpt of `CHANGELOG.md` between those versions for a one-line summary of what changed — or trust the excerpt `update` itself prints in Step 3 and summarize that instead.
+
+Ask one line: *"Atualizar o kit de {from} para {to}? Isso vai re-renderizar os adapters instalados (claude-code, generic, …) e regravar `kit_version` em `project.toml`."*
+
+Never run Step 3 without this confirmation — it rewrites rendered skill/command files that live under version control, and the resulting diff should land as the user's own reviewed commit, not an unreviewed surprise.
+
+## Step 3 — run it
+
+On confirmation:
+
+```
+npx wize-dev-kit@latest update
+```
+
+Relay its output — it already reports per-adapter results and a CHANGELOG excerpt. It is idempotent and additive: it never touches `.wize/config/user.toml`, never removes custom agents/skills under `.wize/custom/`, and only rewrites the `kit_version` line in `project.toml`.
+
+## Step 4 — close the loop
+
+- Flag any adapter the output reported as `skipped` or `error` — those need a manual look.
+- Repeat, in one line, that the IDE/harness needs a restart to pick up refreshed slash commands.
+- Suggest reviewing the diff (`git status` / `git diff`) before committing — this is a real file change, not a no-op.
+
+## When NOT to use
+
+- No `.wize/` folder at all → this is a fresh install, not an update. Route to `npx wize-dev-kit install` (see `wize-onboarding`).
+- The user only wants to know whether an update exists, without applying it → Step 1 alone answers that; do not push into Step 2/3 unasked.

package/tools/check-eli5-all-adapters.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// Verifica que o wize-eli5 é renderizado por TODOS os 10 adapters de harness.
+// Verifica que o wize-eli5 é renderizado por TODOS os 11 adapters de harness.
 'use strict';
 const fs = require('node:fs');
 const path = require('node:path');
@@ -12,6 +12,7 @@ const EXPECT = [
   { code: 'codex',       file: '.agents/skills/wize-eli5/SKILL.md' },
   { code: 'kimi-code',   file: '.kimi/skills/wize-eli5/SKILL.md' },
   { code: 'hermes',      file: '.hermes/skills/wize-eli5/SKILL.md' },
+  { code: 'kiro',        file: '.kiro/skills/wize-eli5/SKILL.md' },
   { code: 'cursor',      file: '.cursor/rules/wize-eli5.mdc' },
   { code: 'windsurf',    file: '.windsurf/rules/wize-eli5.md' },
   { code: 'continue',   file: '.continue/prompts/wize-eli5.prompt' },
@@ -46,5 +47,5 @@ for (const a of EXPECT) {
     fs.rmSync(root, { recursive: true, force: true });
   }
 }
-console.log(`\n${ok}/10 harnesses com wize-eli5.`);
+console.log(`\n${ok}/11 harnesses com wize-eli5.`);
 process.exit(fail ? 1 : 0);

package/tools/installer/baseline.js

@@ -5,7 +5,7 @@
 //
 // Harness priority is:
 //   1. user's selected IDE targets (from .wize/config/project.toml), highest first
-//   2. claude > codex > opencode > hermes (universal fallback)
+//   2. claude > codex > opencode > hermes > kiro-cli (universal fallback)
 //
 // Set WIZE_SKIP_BASELINE=1 in the environment to disable any execution (the
 // install still suggests the next step). Useful for CI and unattended setups.
@@ -40,6 +40,11 @@ const HARNESSES = [
     code: 'hermes',
     binary: 'hermes',
     buildCmd: (prompt) => ({ cmd: 'hermes', args: ['-z', prompt] })
+  },
+  {
+    code: 'kiro',
+    binary: 'kiro-cli',
+    buildCmd: (prompt) => ({ cmd: 'kiro-cli', args: ['chat', '--no-interactive', '--trust-all-tools', prompt] })
   }
 ];
 
@@ -101,7 +106,7 @@ function manualInstructions(harness) {
   if (!harness) {
     return [
       '',
-      'No AI harness CLI was detected on PATH (claude / codex / opencode / hermes).',
+      'No AI harness CLI was detected on PATH (claude / codex / opencode / hermes / kiro-cli).',
       'Open your IDE in this repo and run:',
       '  /wize-document-project',
       ''

package/tools/installer/commands/doctor.js

@@ -61,6 +61,7 @@ function adapterTargetPath(targetCode, projectRoot) {
     case 'codex':        return path.join(projectRoot, '.agents/skills');
     case 'kimi-code':    return path.join(projectRoot, '.kimi/skills');
     case 'hermes':       return path.join(projectRoot, '.hermes/skills');
+    case 'kiro':         return path.join(projectRoot, '.kiro/skills');
     case 'cursor':       return path.join(projectRoot, '.cursor/rules');
     case 'windsurf':     return path.join(projectRoot, '.windsurf/rules');
     case 'continue':     return path.join(projectRoot, '.continue/prompts');

package/tools/installer/commands/version-check.js

@@ -0,0 +1,39 @@
+// `wize-dev-kit version-check` — explicit, agent-friendly version check.
+//
+// The other CLI commands print an opportunistic hint (version-check.js's
+// printUpdateHintIfAny) that stays silent on a non-TTY stdout so it never
+// spams a pipe. This command is the opposite: it was asked for by name —
+// by a human, or by an AI agent shelling out from a skill instruction where
+// stdout is never a TTY — so it always answers, in `--json` when a caller
+// needs to parse it.
+
+'use strict';
+
+const { getVersionCheckResult } = require('../version-check.js');
+
+async function cmdVersionCheck({ currentVersion, json = false, log = console.log } = {}) {
+  const result = await getVersionCheckResult(currentVersion);
+
+  if (json) {
+    log(JSON.stringify(result));
+    return result;
+  }
+
+  if (result.disabled) {
+    log('Update check disabled (WIZE_DISABLE_UPDATE_CHECK=1).');
+    return result;
+  }
+  if (!result.latest) {
+    log(`wize-dev-kit ${result.installed} (could not reach the registry — offline or timed out).`);
+    return result;
+  }
+  if (result.updateAvailable) {
+    log(`↑ Update available: wize-dev-kit ${result.installed} → ${result.latest}`);
+    log('  Run `npx wize-dev-kit@latest update` in your project to refresh adapters — or `/wize-update` from inside your AI harness.');
+  } else {
+    log(`wize-dev-kit ${result.installed} is up to date.`);
+  }
+  return result;
+}
+
+module.exports = { cmdVersionCheck };

package/tools/installer/setup-helpers.js

@@ -25,6 +25,7 @@ const GITIGNORE_BODY = [
   '.agents/skills/wize-*',
   '.kimi/skills/wize-*',
   '.hermes/skills/wize-*',
+  '.kiro/skills/wize-*',
   '.cursor/rules/wize-*.mdc',
   '.windsurf/rules/wize-*.md',
   '.continue/prompts/wize-*.prompt',

package/tools/installer/version-check.js

@@ -104,6 +104,25 @@ async function printUpdateHintIfAny(currentVersion, { log = console.log, isTTY =
   }
 }
 
+// Pure, TTY-agnostic version check. printUpdateHintIfAny above is an
+// opportunistic hint meant for a human's terminal (gated on isTTY so it
+// never spams a pipe or a script); this is the explicit-invocation
+// counterpart behind the `version-check` CLI command, which an AI agent
+// shells out to non-interactively — stdout there is never a TTY, so a
+// TTY-gated check would go silent exactly when it's needed. Always resolves
+// to a plain object, never throws, and shares the same 1h cache.
+async function getVersionCheckResult(currentVersion, { skipCache = false } = {}) {
+  if (process.env.WIZE_DISABLE_UPDATE_CHECK === '1') {
+    return { installed: currentVersion, latest: null, updateAvailable: false, disabled: true };
+  }
+  const latest = await getLatestVersion({ skipCache });
+  return {
+    installed: currentVersion,
+    latest: latest || null,
+    updateAvailable: latest ? semverGreater(latest, currentVersion) : false
+  };
+}
+
 module.exports = {
   CACHE_TTL_MS,
   NETWORK_TIMEOUT_MS,
@@ -113,5 +132,6 @@ module.exports = {
   fetchLatestFromRegistry,
   getLatestVersion,
   semverGreater,
-  printUpdateHintIfAny
+  printUpdateHintIfAny,
+  getVersionCheckResult
 };

package/tools/installer/wize-cli.js

@@ -5,7 +5,7 @@
  *
  * v0.15.0 — Full-lifecycle CLI with install, update, uninstall, list, sync,
  * agent, workflow, validate, doctor, and document-project commands. Adapters
- * render for 10 IDE targets. Security overlay ships with 8 tools.
+ * render for 11 IDE targets. Security overlay ships with 8 tools.
  * `install --yes` now enables all harnesses + all overlays by default.
  */
 'use strict';
@@ -19,6 +19,7 @@ const prompts = require('prompts');
 const { applyGitignore, generateUserToml } = require('./setup-helpers.js');
 const { cmdUpdate, loadProjectConfig } = require('./commands/update.js');
 const { printUpdateHintIfAny } = require('./version-check.js');
+const { cmdVersionCheck } = require('./commands/version-check.js');
 const { cmdSync: cmdSyncReal } = require('./commands/sync.js');
 const { cmdAgentList, cmdAgentCreate, cmdAgentEdit } = require('./commands/agent.js');
 const { cmdDoctor, adapterTargetPath } = require('./commands/doctor.js');
@@ -38,6 +39,7 @@ const TARGETS = [
   { code: 'continue', label: 'Continue', default: false },
   { code: 'kimi-code', label: 'Kimi Code', default: false },
   { code: 'hermes', label: 'Hermes Agent (.hermes/skills/)', default: false },
+  { code: 'kiro', label: 'Kiro — AWS (.kiro/skills/)', default: false },
   { code: 'opencode', label: 'OpenCode', default: false },
   { code: 'antigravity', label: 'Antigravity (CLI + IDE)', default: false },
   { code: 'generic', label: 'Generic fallback (.wize/agents/)', default: true }
@@ -72,6 +74,7 @@ Usage:
 Commands:
   install                 Install the kit into the current repo (interactive).
   update                  Apply upstream diff while preserving customizations.
+  version-check [--json]  Check installed vs. latest version (scriptable; never blocks).
   uninstall               Remove the kit from the current repo (preserves code).
   list                    List installed agents, skills and workflows.
   sync                    Regenerate IDE adapters for active targets.
@@ -890,6 +893,8 @@ async function main() {
   switch (cmd) {
     case 'install':   return cmdInstall(rest);
     case 'update':    return cmdUpdate({ kitRoot: KIT_ROOT, projectRoot: process.cwd() });
+    case 'version-check':
+      return cmdVersionCheck({ currentVersion: KIT_VERSION, json: rest.includes('--json') });
     case 'uninstall': return cmdUninstall(rest);
     case 'list':      return cmdList();
     case 'sync':      return cmdSync();