wize-dev-kit 0.13.0 → 0.15.0

package/AGENTS.md

@@ -2,7 +2,7 @@
 
 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 all read this file).
+using slash commands (Claude Code, Codex, Cursor, Windsurf, Antigravity, Hermes all read this file).
 
 ## Operating context
 

package/CHANGELOG.md

@@ -9,6 +9,29 @@ Format inspired by [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.15.0] — 2026-09-02
+
+**Hermes Agent is now the 10th supported harness.** New `hermes` IDE target renders the kit's agents/skills/workflows as project-local skills at `.hermes/skills/wize-{code}/SKILL.md` (Anthropic-compatible format, same as Claude Code/Codex/Kimi Code). Hermes discovers project skills at the git root, loads them only when the repo is trusted (`hermes skills trust`), and lets trusted project skills override same-named profile skills — vendored repo skills win inside their repo. Hermes also reads root `AGENTS.md` as project context, and its CLI (`hermes -z "<prompt>"`) is registered in the installer's brownfield baseline for headless runs. Highlighted in all 3 READMEs + `docs/harnesses/hermes.md` (+pt-BR); registered in the installer targets, `doctor`, `.gitignore` block, and 4 test suites.
+
+### Added
+
+- **`hermes` IDE target** (`adapters/hermes/`) — renders via the shared Anthropic emitter to `.hermes/skills/`; companion files (`steps/`, `templates/`, `data/`) copied alongside `SKILL.md`. Selectable in `npx wize-dev-kit install` / `sync`; `install --yes` now enables 10 harnesses.
+- **`docs/harnesses/hermes.md` + `hermes.pt-BR.md`** — output layout, trust-gate setup (`hermes skills trust` / `skills.trusted_project_dirs`), precedence rules, and headless usage.
+
+### Changed
+
+- **Installer** — `TARGETS` gains `hermes`; `adapterTargetPath()` maps it to `.hermes/skills` (also covers `uninstall`); `.gitignore` block ignores `.hermes/skills/wize-*`; brownfield `baseline.js` detects the `hermes` CLI and runs `hermes -z` headlessly.
+- **Docs** — README (en/pt-BR/es) harness tables and summaries now list **10** IDE targets, with Hermes highlighted as new; `AGENTS.md` (repo + generated template) lists Hermes among the harnesses that read it.
+- **Tests** — adapter emit/companion coverage, structure, `install --yes` full-defaults, and `doctor` path mapping all now include `hermes`.
+
+## [0.14.0] — 2026-08-31
+
+**`wize-check` — progress checklist with evidence.** A read-only orchestrator skill (owner: Wizer) that answers "where are we, what's done, what's left" mid-session without advancing or re-planning the work. The **evidence rule** is the core: an item only reaches *Done* with a commit, `file:line`, a passed command, a recorded gate, or a merged PR — intent and plans are never evidence. Done condition comes first: if it is not explicit, the skill states the assumed criterion and asks for confirmation instead of inventing a destination. After reporting, it resumes the interrupted work. Modes: default, `now`, `save` (`.wize/implementation/checks/`), `{topic}`. Registered in the orchestrator catalog, the intent routing table (Meta), all 9 harness adapters, READMEs (3 languages) and CHANGELOG. Suite green (539 tests, validate 80 files).
+
+### Added
+
+- **`wize-check`** (orchestrator skill) — read-only progress checklist for the demand in flight: objective (done condition), where we are, done / in progress / left / blocked, and one next step. Enforces an **evidence rule** (an item only reaches *Done* with a commit, `file:line`, a command that passed, or a recorded gate) so progress is never overstated, then **resumes the interrupted work**. Modes: default, `now`, `save`, `{topic}`. Complements `wize-sprint-status` (sprint detail), `wize-checkpoint-preview` (continue/pivot decision) and `wize-correct-course` (re-plan) without replacing any of them. Intent phrases: "checklist", "o que falta", "o que já foi feito", "acompanhamento", "me atualiza", "cadê que paramos", "what's left".
+
 ## [0.13.0] — 2026-08-28
 
 **`install --yes` now installs everything.** The quick install (`npx wize-dev-kit install --yes`) previously defaulted to the core profile and the Claude Code + generic harnesses only. It now enables **all 4 profiles** (core + web-overlay + app-overlay + security-overlay) and **all 9 harnesses** (claude-code, cursor, windsurf, codex, continue, kimi-code, opencode, antigravity, generic) — a true one-shot full install. Explicit `--profiles` / `--targets` flags still narrow the selection.

package/README.es.md

@@ -69,7 +69,7 @@ Tras instalar, abre tu IDE y di:
 
 ## Harnesses soportados
 
-Los 9 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 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.
 
 | Harness | Salida | Destacado |
 |---|---|---|
@@ -77,6 +77,7 @@ Los 9 IDEs objetivo se renderizan desde la misma fuente; el formato y la mecáni
 | **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) |
 | **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) |
@@ -152,6 +153,9 @@ 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.
@@ -252,7 +256,7 @@ npx wize-dev-kit version         # imprime la versión instalada del kit
 
 ## 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, 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 9.
+**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.
 
 ---
 

package/README.md

@@ -69,7 +69,7 @@ After install, open your IDE and say:
 
 ## Supported harnesses
 
-All 9 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 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.
 
 | Harness | Output | Notable |
 |---|---|---|
@@ -77,6 +77,7 @@ All 9 IDE targets render from the same source; format and mechanics differ per h
 | **Claude Code** | `.claude/skills/*/SKILL.md` | Anthropic Skill format; ad-hoc Task/Agent-tool fan-out (`wize-code-review`). [Docs →](docs/harnesses/claude-code.md) |
 | **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) |
 | **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) |
@@ -150,6 +151,9 @@ Cross-cutting:
     /wize-help                  Wizer routes you: `next` (single next action),
                                 `status` (project snapshot), `mission` (a filled
                                 mission contract for the executing persona).
+    /wize-check                 Progress checklist for the demand in flight:
+                                done (with evidence), in progress, what's left —
+                                then resumes the interrupted work.
     /wize-grill                 Interview-to-understanding before any authoring step.
     /wize-quick-dev             Shuri takes a small fix without the full ride.
     /wize-pre-pr-check          Run lint/format/build/unit tests locally before
@@ -247,7 +251,7 @@ npx wize-dev-kit version         # print the installed kit version
 
 ## Status
 
-**v0.12.1 — beta.** The method never produces development estimates — no hours, points, or t-shirt sizes; a story is sized only by whether it fits a single PR. The full lifecycle (analysis → plan → solution → implementation) is wired with 10 agents and a structured skill library. Recent releases add **mission contracts** (`/wize-help mission`), **`wize-grill`** (interview-to-shared-understanding before any authoring step), **`wize-pre-pr-check`** (local lint/format/build/unit-test gate before opening a PR — zero CI runner cost), and **loop verification** in `wize-dev-story` (a self-checking implementation loop with a max-cycles guard that escalates to `wize-correct-course`). The `security-overlay` (AI Pentester) ships a complete pentest pipeline, a stakeholder report (risk score + briefing + AI action plan), and post-scan remediation planning — validated end-to-end against a real Laravel/PHP app. IDE adapters for Claude Code, Cursor, Windsurf, Codex, Continue, Kimi Code, OpenCode, and Antigravity are regenerated automatically — [OpenCode](docs/harnesses/opencode.md) gets native `mode`/`agent`/`subtask` wiring, the deepest integration of the 9.
+**v0.12.1 — beta.** The method never produces development estimates — no hours, points, or t-shirt sizes; a story is sized only by whether it fits a single PR. The full lifecycle (analysis → plan → solution → implementation) is wired with 10 agents and a structured skill library. Recent releases add **mission contracts** (`/wize-help mission`), **`wize-grill`** (interview-to-shared-understanding before any authoring step), **`wize-pre-pr-check`** (local lint/format/build/unit-test gate before opening a PR — zero CI runner cost), and **loop verification** in `wize-dev-story` (a self-checking implementation loop with a max-cycles guard that escalates to `wize-correct-course`). The `security-overlay` (AI Pentester) ships a complete pentest pipeline, a stakeholder report (risk score + briefing + AI action plan), and post-scan remediation planning — validated end-to-end against a real Laravel/PHP app. IDE adapters for Claude Code, Cursor, Windsurf, Codex, Continue, Kimi Code, Hermes, OpenCode, and Antigravity are regenerated automatically — [OpenCode](docs/harnesses/opencode.md) gets native `mode`/`agent`/`subtask` wiring, the deepest integration of the 10.
 
 ---
 

package/README.pt-BR.md

@@ -69,7 +69,7 @@ Após instalar, abra sua IDE e diga:
 
 ## Harnesses suportadas
 
-Os 9 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 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.
 
 | Harness | Saída | Destaque |
 |---|---|---|
@@ -77,6 +77,7 @@ Os 9 alvos de IDE são gerados a partir da mesma fonte; formato e mecânica muda
 | **Claude Code** | `.claude/skills/*/SKILL.md` | Formato Skill da Anthropic; fan-out ad hoc via Task/Agent tool (`wize-code-review`). [Docs →](docs/harnesses/claude-code.pt-BR.md) |
 | **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) |
 | **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) |
@@ -151,6 +152,9 @@ Transversais:
     /wize-help                  Wizer te direciona: `next` (próxima ação única),
                                 `status` (snapshot do projeto), `mission` (contrato
                                 de missão preenchido para a persona executora).
+    /wize-check                 Checklist de acompanhamento da demanda em voo:
+                                feito (com evidência), em andamento, o que falta —
+                                depois retoma o trabalho interrompido.
     /wize-grill                 Entrevista-até-entendimento antes de qualquer passo
                                 de autoria.
     /wize-quick-dev             Shuri pega uma correção pequena sem o ciclo completo.
@@ -250,7 +254,7 @@ npx wize-dev-kit version         # imprime a versão instalada do kit
 
 ## Status
 
-**v0.12.1 — beta.** O método nunca produz estimativas de desenvolvimento — nada de horas, pontos ou tamanhos de camiseta; uma story é dimensionada apenas por caber (ou não) em um único PR. O ciclo completo (análise → plano → solução → implementação) está montado com 10 agentes e uma biblioteca estruturada de skills. Releases recentes adicionam **contratos de missão** (`/wize-help mission`), **`wize-grill`** (entrevista-até-entendimento antes de qualquer passo de autoria), **`wize-pre-pr-check`** (gate local de lint/format/build/testes unitários antes de abrir um PR — zero custo de runner de CI) e **loop verification** no `wize-dev-story` (loop de implementação auto-verificável com guarda de max-cycles que escala para `wize-correct-course`). O `security-overlay` (Pentester de IA) entrega um pipeline de pentest completo, um relatório executivo (score de risco + briefing + plano de ação por IA) e planejamento de correção pós-scan — validado de ponta a ponta contra uma aplicação Laravel/PHP real. Os adapters de IDE para Claude Code, Cursor, Windsurf, Codex, Continue, Kimi Code, OpenCode e Antigravity são regenerados automaticamente — o [OpenCode](docs/harnesses/opencode.pt-BR.md) tem a integração mais profunda das 9, com `mode`/`agent`/`subtask` nativos.
+**v0.12.1 — beta.** O método nunca produz estimativas de desenvolvimento — nada de horas, pontos ou tamanhos de camiseta; uma story é dimensionada apenas por caber (ou não) em um único PR. O ciclo completo (análise → plano → solução → implementação) está montado com 10 agentes e uma biblioteca estruturada de skills. Releases recentes adicionam **contratos de missão** (`/wize-help mission`), **`wize-grill`** (entrevista-até-entendimento antes de qualquer passo de autoria), **`wize-pre-pr-check`** (gate local de lint/format/build/testes unitários antes de abrir um PR — zero custo de runner de CI) e **loop verification** no `wize-dev-story` (loop de implementação auto-verificável com guarda de max-cycles que escala para `wize-correct-course`). O `security-overlay` (Pentester de IA) entrega um pipeline de pentest completo, um relatório executivo (score de risco + briefing + plano de ação por IA) e planejamento de correção pós-scan — validado de ponta a ponta contra uma aplicação Laravel/PHP real. Os adapters de IDE para Claude Code, Cursor, Windsurf, Codex, Continue, Kimi Code, Hermes, OpenCode e Antigravity são regenerados automaticamente — o [OpenCode](docs/harnesses/opencode.pt-BR.md) tem a integração mais profunda das 10, com `mode`/`agent`/`subtask` nativos.
 
 ---
 

package/adapters/README.md

@@ -12,6 +12,7 @@ Each adapter renders the kit's agents/skills/workflows into the file layout that
 | `codex` | `.agents/skills/wize-*/` | `SKILL.md` per agent/workflow | OpenAI Codex. |
 | `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). |
 | `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/hermes/README.md

@@ -0,0 +1,23 @@
+# Hermes Agent — Wize Dev Kit Adapter
+
+Emits the kit's agents/skills/workflows as Hermes project-local skills under
+`.hermes/skills/wize-{code}/SKILL.md`, using the Anthropic `SKILL.md` format
+that Hermes consumes verbatim (same as Claude Code / Codex / Kimi Code).
+
+## How Hermes picks these up
+
+- Hermes discovers project-local skills at `<git-root>/.hermes/skills/`
+  (Hermes-native) and `<git-root>/.agents/skills/` (cross-tool convention).
+- **Trust gate:** skills are only loaded when the repo root is trusted. Run
+  `hermes skills trust` (or add the repo to `skills.trusted_project_dirs` in
+  `~/.hermes/config.yaml`) once per checkout.
+- Trusted project skills **override** same-named profile/bundled skills —
+  vendored repo skills win inside their repo.
+- Hermes also reads root-level `AGENTS.md` (and `CLAUDE.md`, `.cursorrules`)
+  as project context, so installing the generic target alongside is a bonus,
+  not a requirement.
+
+## Files
+
+- `render.js` — renders via the shared `renderAnthropicSkills` emitter.
+- `adapter.yaml` — descriptor (target path, file pattern).

package/adapters/hermes/adapter.yaml

@@ -0,0 +1,8 @@
+code: hermes
+description: "Hermes Agent skills (.hermes/skills/, Anthropic-compatible, project-local)."
+target_path: ".hermes/skills/"
+file_pattern: "wize-*/SKILL.md"
+file_format: markdown
+hooks:
+  pre_render: []
+  post_render: []

package/adapters/hermes/render.js

@@ -0,0 +1,17 @@
+// Hermes Agent adapter — emits .hermes/skills/wize-{code}/SKILL.md per asset.
+// Hermes consumes the Anthropic SKILL.md format verbatim (same as Claude Code,
+// Codex, Kimi Code). Project-local skills live at <repo-root>/.hermes/skills/
+// and are only loaded when the repo root is trusted (`hermes skills trust`),
+// mirroring the OpenCode/Codex `.agents/skills/` convention.
+
+'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, '.hermes', 'skills');
+  return renderAnthropicSkills(kitRoot, targetDir, opts);
+}
+
+module.exports = { render };

package/docs/harnesses/hermes.md

@@ -0,0 +1,26 @@
+# Hermes Agent — Wize Development Kit
+
+🌐 **Languages:** **English** · [Português (pt-BR)](hermes.pt-BR.md)
+
+← [Back to README](../../README.md)
+
+Hermes Agent consumes the same public Anthropic Skill format as Claude Code, Codex, and Kimi Code, as project-local skills.
+
+## Output
+
+`.hermes/skills/wize-{code}/SKILL.md` — one directory per persona, workflow, or skill, with companion files (`steps/`, `templates/`, `data/`) copied alongside.
+
+## Notable
+
+- **Project-local skills.** Hermes discovers `<git-root>/.hermes/skills/` (Hermes-native) and `<git-root>/.agents/skills/` (cross-tool convention) for sessions started inside that project.
+- **Trust gate.** Skills are load-on-demand procedure documents, so Hermes only loads project skills when the repo root is trusted — run `hermes skills trust` (or add the root to `skills.trusted_project_dirs` in `~/.hermes/config.yaml`) once per checkout. Untrusted repos are still discoverable with a one-line notice.
+- **Precedence.** Trusted project skills override same-named profile/bundled skills — vendored repo skills win inside their repo.
+- Hermes also reads root-level `AGENTS.md` (plus `CLAUDE.md`, `.cursorrules`) as project context, so pairing with the **Generic fallback** target is a bonus.
+
+## Setup
+
+Pick **Hermes Agent** as an IDE target during `npx wize-dev-kit install` (or add it and re-run `npx wize-dev-kit sync`). Run `hermes skills trust` in the repo, restart Hermes, then run `/wize-orchestrator`.
+
+## Headless
+
+`hermes -z "<prompt>"` runs a one-shot headless session, which the installer's brownfield baseline uses when Hermes is the detected harness CLI.

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

@@ -0,0 +1,26 @@
+# Hermes Agent — Wize Development Kit
+
+🌐 **Idiomas:** [English](hermes.md) · **Português (pt-BR)**
+
+← [Voltar ao README](../../README.pt-BR.md)
+
+O Hermes Agent consome o mesmo formato público de Skill da Anthropic usado pelo Claude Code, Codex e Kimi Code, na forma de skills project-local.
+
+## Saída
+
+`.hermes/skills/wize-{code}/SKILL.md` — um diretório por persona, workflow ou skill, com arquivos complementares (`steps/`, `templates/`, `data/`) copiados junto.
+
+## Destaques
+
+- **Skills project-local.** O Hermes descobre `<git-root>/.hermes/skills/` (nativo do Hermes) e `<git-root>/.agents/skills/` (convenção compartilhada) para sessões iniciadas dentro do projeto.
+- **Trust gate.** Skills são documentos de procedimento carregados sob demanda, então o Hermes só carrega skills do projeto quando a raiz do repositório é confiável — rode `hermes skills trust` (ou adicione a raiz em `skills.trusted_project_dirs` no `~/.hermes/config.yaml`) uma vez por checkout. Repositórios não confiáveis seguem detectáveis com um aviso de uma linha.
+- **Precedência.** Skills project-local confiáveis sobrescrevem skills de mesmo nome do perfil/bundle — skills versionadas no repo vencem dentro do próprio repo.
+- O Hermes também lê `AGENTS.md` na raiz (além de `CLAUDE.md`, `.cursorrules`) como contexto de projeto, então combinar com o alvo **Fallback genérico** é um bônus.
+
+## Como ativar
+
+Escolha **Hermes Agent** como alvo de IDE em `npx wize-dev-kit install` (ou adicione depois e rode `npx wize-dev-kit sync`). Rode `hermes skills trust` no repo, reinicie o Hermes e rode `/wize-orchestrator`.
+
+## Headless
+
+`hermes -z "<prompt>"` roda uma sessão headless de uma execução, usada pelo baseline brownfield do instalador quando o Hermes é o CLI de harness detectado.

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "wize-dev-kit",
-  "version": "0.13.0",
+  "version": "0.15.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

@@ -19,6 +19,9 @@ skills:
   - code: wize-help
     name: "Help (Wizer)"
     description: "Canonical help skill. Project-state-aware help. Reads .wize/ and tells the user what to do next. Modes: default, next, status, personas."
+  - 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-onboarding
     name: "Onboarding"
     description: "Post-install triage: greenfield vs brownfield, profile, objective. Delegates to specialists."

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

@@ -0,0 +1,98 @@
+---
+
+code: wize-check
+description: "Use quando o usuário pedir clareza de acompanhamento no meio do trabalho — um checklist de onde estamos, o que já foi feito, o que falta e o que trava, até a condição de pronto."
+name: Check (Wizer)
+module: orchestrator
+owner: wize-orchestrator
+status: ready
+aliases: []
+---
+
+# Wizer · `/wize-check`
+
+**Goal.** In under 60 seconds, return a **progress checklist** for the demand in flight: what the objective is, where we are, what is already done (with evidence), what is in progress, what is left until the done condition, and what is waiting on the user.
+
+This is a **read-only interruption**. It does not edit code, does not advance the task, does not re-plan. After answering, **resume exactly the work that was in flight**, at the step where it stopped.
+
+## Modes
+
+| Invocation | What to do |
+|---|---|
+| `/wize-check` | Full checklist for the demand in flight. |
+| `/wize-check now` | Two lines only: what I'm doing right now + the next step. |
+| `/wize-check {topic}` | Narrow the checklist to one scope (a story, a PR, a bug, a document). |
+| `/wize-check save` | Same checklist, plus write it to `.wize/implementation/checks/{YYYY-MM-DD-HHmm}.md`. |
+
+## Step 1 — reconstruct the state (in this order)
+
+1. **The session itself** — the original request, the decisions already taken, the files edited, the commands run and what they returned. This is the primary source.
+2. **Work still in flight** — background commands, pending subagents, a PR awaiting review, CI running. It goes under *in progress*, never under *done*.
+3. **Kit artifacts** (when they exist): `.wize/implementation/sprint-status.yaml`, the story in flight under `.wize/solutioning/stories/**`, the latest `.wize/implementation/tea/**/gate.md`.
+4. **Git** (if this is a repository): current branch, `git status`, commits since the base, open PR.
+5. **Project memory / pointers** — only to recall the stated objective, never as proof of execution.
+
+## Step 2 — evidence rule (non-negotiable)
+
+An item only reaches **Done** with verifiable proof: a file and line, a commit, a command that ran and passed, a recorded gate, a merged PR.
+
+- No proof → **In progress** or **Unverified**, said out loud.
+- Intent, a plan, or "I implemented it" are not evidence.
+- If something was written but not validated, the item is `[~]` with the missing validation named next to it.
+
+Overstating progress is the one serious failure mode of this skill.
+
+## Step 3 — the done condition (the "until we get to…")
+
+Before building the list, write in one line **where this demand ends** — the observable result that closes it.
+
+- If it is explicit in the session or in the artifacts, quote it.
+- If it is not, **state the criterion you assumed** and ask for confirmation in one line. Never invent a destination silently.
+
+## Step 4 — build the checklist
+
+```markdown
+## Checklist — {demand in one line}
+
+**Objective:** {done condition — the observable result}
+**Where we are:** {phase} · step {X} of {Y}
+
+### Done
+- [x] {item} — {evidence: commit / file:line / command that passed}
+
+### In progress
+- [~] {item} — {what is missing to close it}
+
+### Left
+- [ ] {item} — {who executes: skill or person}
+
+### Blocked / waiting on you
+- {decision, credential, approval — or "nothing"}
+
+**Progress:** {n}/{total} · **Next step:** {one action, one line}
+```
+
+### Shape rules
+
+- At most ~12 items total. Group; do not list micro-steps.
+- Order **Left** by dependency, not by importance.
+- One single next step. If two candidates tie, pick one and say why in half a line.
+- No preamble, no closing summary, no praise for the progress.
+- If a section is empty, write "—" and move on. Never invent an item to fill it.
+- If an item **regressed** (broke, was reverted, gate flipped to FAIL), it goes back to *In progress* with the cause next to it.
+
+## Step 5 — resume
+
+After the checklist, return to the interrupted work without asking permission and without reopening the plan — unless the checklist itself surfaced a blocker that needs a decision from the user. In that case, stop and ask.
+
+## When NOT to use
+
+- Full sprint detail (stories, capacity, priorities) → `wize-sprint-status`.
+- A continue / pivot / stop decision mid-story → `wize-checkpoint-preview`.
+- Sprint off the rails, needs re-planning → `wize-correct-course`.
+
+`wize-check` only reports. If the checklist shows the plan is wrong, say so in one line and point at the skill above — do not re-plan here.
+
+## Hand-off
+
+> Checklist delivered. Resuming: {next step}.

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

@@ -182,6 +182,7 @@ Match is case-insensitive, substring-based. Longest match wins. When no intent m
 |---|---|
 | "help", "ajuda", "o que fazer", "próximo passo", "what next" | Show status + next step (no skill dispatch) |
 | "status", "como estamos", "onde estamos", "progresso" | Show sprint status / project snapshot |
+| "checklist", "o que falta", "o que já foi feito", "acompanhamento", "me atualiza", "cadê que paramos", "what's left" | `wize-check` |
 | "retrospective", "retrospectiva", "retro", "lições aprendidas" | `wize-retrospective` |
 | "personas", "quem faz o quê", "roster", "equipe" | List personas relevant to active profiles |
 | "mission", "missão", "contrato", "mission contract" | Emit filled mission contract |

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 (universal fallback)
+//   2. claude > codex > opencode > hermes (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.
@@ -35,6 +35,11 @@ const HARNESSES = [
     code: 'opencode',
     binary: 'opencode',
     buildCmd: (prompt) => ({ cmd: 'opencode', args: ['run', prompt] })
+  },
+  {
+    code: 'hermes',
+    binary: 'hermes',
+    buildCmd: (prompt) => ({ cmd: 'hermes', args: ['-z', prompt] })
   }
 ];
 
@@ -96,7 +101,7 @@ function manualInstructions(harness) {
   if (!harness) {
     return [
       '',
-      'No AI harness CLI was detected on PATH (claude / codex / opencode).',
+      'No AI harness CLI was detected on PATH (claude / codex / opencode / hermes).',
       'Open your IDE in this repo and run:',
       '  /wize-document-project',
       ''

package/tools/installer/commands/doctor.js

@@ -60,6 +60,7 @@ function adapterTargetPath(targetCode, projectRoot) {
     case 'antigravity':  return path.join(projectRoot, '.agent/skills');
     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 '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/render-shared.js

@@ -286,7 +286,7 @@ function renderAgentsMd(kitRoot, projectRoot, opts = {}) {
     '',
     '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 all read this file).',
+    'using slash commands (Claude Code, Codex, Cursor, Windsurf, Antigravity, Hermes all read this file).',
     '',
     '## Operating context',
     '',

package/tools/installer/setup-helpers.js

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

package/tools/installer/wize-cli.js

@@ -3,9 +3,9 @@
  * wize-dev-kit — CLI entry point
  * Subcommands: install, update, uninstall, list, sync, agent, workflow, help
  *
- * v0.13.0 — Full-lifecycle CLI with install, update, uninstall, list, sync,
+ * v0.15.0 — Full-lifecycle CLI with install, update, uninstall, list, sync,
  * agent, workflow, validate, doctor, and document-project commands. Adapters
- * render for 9 IDE targets. Security overlay ships with 8 tools.
+ * render for 10 IDE targets. Security overlay ships with 8 tools.
  * `install --yes` now enables all harnesses + all overlays by default.
  */
 'use strict';
@@ -37,6 +37,7 @@ const TARGETS = [
   { code: 'codex', label: 'Codex', default: false },
   { code: 'continue', label: 'Continue', default: false },
   { code: 'kimi-code', label: 'Kimi Code', default: false },
+  { code: 'hermes', label: 'Hermes Agent (.hermes/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 }