wize-dev-kit 0.20.0 → 0.22.0

package/CHANGELOG.md

@@ -7,6 +7,37 @@ 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).
 
+## [0.22.0] — 2026-09-25
+
+**GitHub Copilot is now the 12th supported harness.** The new `copilot` IDE target renders the kit into the two trees Copilot actually reads: `.github/skills/wize-{code}/SKILL.md` for workflows + skills (Agent Skills standard) and `.github/agents/wize-{code}.agent.md` for the 10 personas (custom agents, pickable in the chat dropdown). Works across the Copilot cloud agent, Copilot code review, the GitHub Copilot CLI, the Copilot app, and agent mode in VS Code, JetBrains IDEs, Eclipse and Xcode. Highlighted in all 3 READMEs + `docs/harnesses/copilot.md` (+pt-BR); registered in the installer targets, `doctor`, the `.gitignore` block, the brownfield baseline and the test suites.
+
+### Added
+
+- **`copilot` IDE target** (`adapters/copilot/`) — personas → `.github/agents/*.agent.md` (frontmatter `name` + `description`, persona body as the prompt, `tools` omitted so each persona keeps every available tool); workflows + skills → `.github/skills/*/SKILL.md` via the shared Anthropic emitter, including companion files (`steps/`, `templates/`, `data/`, `*.csv`) so micro-file workflows resolve their relative paths.
+- **`copilot` harness in the brownfield baseline** — headless one-shot via `copilot -p "<prompt>"` (grant the minimum permissions you need for unattended runs, e.g. `--allow-tool=write`, instead of `--allow-all`).
+- **`docs/harnesses/copilot.md` + `copilot.pt-BR.md`** — the skill vs custom-agent split, progressive disclosure, `AGENTS.md` as the always-on instructions source (no `.github/copilot-instructions.md` duplicate is written), why prompt files are deliberately not shipped (VS Code deprecated `.github/prompts/*.prompt.md` in favor of agent skills), and the headless invocation.
+- **`renderAnthropicSkills` accepts an optional `opts.kinds` filter** — one emitter now serves harnesses that split assets across trees (Copilot sends workflows/skills to `.github/skills/` and personas to `.github/agents/`) without duplicating the rendering logic.
+
+## [0.21.0] — 2026-09-25
+
+**Less code, and a way to verify it.** Four changes put the kit's reuse discipline to work *after* the code is written, not only while it is being written: a deletion-first review (`/wize-subtract`) wired as a fourth layer of `wize-code-review`, a ledger for deliberate shortcuts (`/wize-debt` + the `wize-debt:` marker), the code ladder promoted into the generated `AGENTS.md` (always-on in every harness), and code accounting in the retrospective. Inspired by [Ponytail](https://github.com/DietrichGebert/ponytail) by Dietrich Gebert (credited in all 3 READMEs).
+
+### Added
+
+- **`/wize-subtract`** (core skill) — over-engineering-only review of a diff: one line per finding (`delete:`, `stdlib:`, `native:`, `yagni:`, `shrink:`), ranked by lines saved, closing with `net: -<N> lines possible.` Names the replacement for every cut, verifies reuse claims against the codebase, and never flags tests, trust-boundary validation, security or accessibility. Lists findings; does not apply them.
+- **`/wize-debt`** (core skill) — harvests every `wize-debt:` marker (ceiling + upgrade path) into one ledger, so a deferral can't quietly become permanent. Flags markers that name no trigger as `no-trigger` rot risk. Read-only.
+- **`wize-code-review` runs a fourth layer: the Subtraction Hunter** — alongside the Blind Hunter, Edge Case Hunter and Acceptance Auditor on every code PR. Triage classifies its findings (`patch` for code this diff introduced, `defer` for pre-existing code, `dismiss` when a requirement or a safety floor protects it) and the summary reports the cuts and `net: -N lines possible`.
+- **Code accounting in `wize-retrospective`** — lines added/removed/net, files touched, dependencies added, new abstractions, `wize-debt:` markers added vs retired, and the complexity delta, all measured from git over the sprint window and reported as numbers in the retro doc.
+
+### Changed
+
+- **The generated `AGENTS.md` now carries the code ladder** — YAGNI → already-here → stdlib → native → installed dependency → one-liner → minimum, plus the anti-over-engineering rules (no unrequested abstractions or dependencies, deletion over addition, boring over clever, fewest files, bug fix = root cause) and the safety floor (trust-boundary validation, data-loss handling, security, accessibility, tests on non-trivial logic). The ladder is now **always-on** in every harness that reads `AGENTS.md`, instead of living only inside the implementation skills. Existing installs: delete the kit-generated `AGENTS.md` and re-run `npx wize-dev-kit sync` to regenerate it.
+- **Shuri's persona** — the blanket "no TODO" rule becomes "no *vague* TODO": a deliberate shortcut with a known ceiling ships with a `wize-debt:` marker naming ceiling and upgrade trigger, or it doesn't ship. Shuri also runs `/wize-subtract` on her own diff before opening the PR.
+
+### Fixed
+
+- **Validator: descriptions with escaped quotes** — the kit's frontmatter parser reads double-quoted scalars with `/^"([^"]*)"$/`, so a `description` containing `\"` was parsed with its wrapping quotes and re-escaped on render (visible in every harness). `npm run validate` now fails that pattern, with the fix spelled out.
+
 ## [0.20.0] — 2026-09-18
 
 ### Added

package/README.es.md

@@ -69,12 +69,13 @@ Tras instalar, abre tu IDE y di:
 
 ## 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.
+Los 12 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) |
+| **GitHub Copilot** 🆕 | `.github/skills/*/SKILL.md` + `.github/agents/*.agent.md` | Agent Skills standard para workflows/skills, **custom agents** para las 10 personas (seleccionables en el desplegable del chat); contexto always-on vía `AGENTS.md`; funciona en el cloud agent, code review, CLI, app y agent mode de VS Code/JetBrains. [Docs →](docs/harnesses/copilot.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) |
@@ -170,7 +171,14 @@ Transversales:
     /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-code-review           Revisión adversarial antes del gate TEA de Hawkeye
+                                (4 capas: ciega, casos-límite, sustracción, auditoría de AC).
+    /wize-subtract              Revisión de diff enfocada solo en over-engineering:
+                                lista de cortes (delete / stdlib / native / yagni /
+                                shrink) + el total de líneas ahorrables. También es capa.
+    /wize-debt                  Cosecha cada atajo deliberado marcado con `wize-debt:`
+                                (techo + ruta de upgrade) en un ledger único, para que
+                                "después" no se vuelva "nunca".
     /wize-party-mode            Wizer reúne multi-persona para decisiones difíciles.
 ```
 
@@ -273,6 +281,8 @@ npx wize-dev-kit version-check [--json]  # instalada vs. más reciente (con cach
 - [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.
 - [No AI Slop](https://github.com/petergyang/no-ai-slop) por Peter Yang — higiene de escrita que elimina patrones de AI slop sin aplanar la voz del autor; la inspiración para `/wize-no-ai-slop`.
 - [apple-appstore-reviewer (awesome-copilot)](https://github.com/github/awesome-copilot/blob/main/skills/apple-appstore-reviewer/SKILL.md) — auditoría con mentalidad de reviewer para la submisión a App Store; la inspiración para `wize-app-store-review` (gate de publicación del overlay).
+- [ELI5](https://github.com/dreambigou/eli5) por Andrew Ou — explicaciones calibradas al oyente; inspiración de `/wize-eli5`.
+- [Ponytail](https://github.com/DietrichGebert/ponytail) por Dietrich Gebert — revisión orientada a la eliminación (`/wize-subtract`), el marcador de atajo `wize-debt:` con su ledger, y el encuadre medido de "menos código" detrás de la contabilidad de código de la retrospectiva. La reuse ladder del kit comparte los mismos peldaños.
 
 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.
 

package/README.md

@@ -69,12 +69,13 @@ After install, open your IDE and say:
 
 ## Supported harnesses
 
-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.
+All 12 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 |
 |---|---|---|
 | **OpenCode** 🆕 | `.opencode/agents/` + `.opencode/commands/` | Native `mode: primary\|subagent`; commands auto-bind to their owning persona (`agent:`); fan-out workers run isolated (`subtask: true`). [Docs →](docs/harnesses/opencode.md) |
 | **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) |
+| **GitHub Copilot** 🆕 | `.github/skills/*/SKILL.md` + `.github/agents/*.agent.md` | Agent Skills standard for workflows/skills, **custom agents** for the 10 personas (pickable in the chat dropdown); always-on context via `AGENTS.md`; works in the cloud agent, code review, CLI, app and VS Code/JetBrains agent mode. [Docs →](docs/harnesses/copilot.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) |
@@ -169,7 +170,14 @@ Cross-cutting:
                                 opening a PR — fail fast, zero CI runner cost.
     /wize-correct-course        Re-plan when a gate fails or a loop stalls (auto-
                                 triggered by the max-cycles guard; also manual).
-    /wize-code-review           Adversarial peer review before Hawkeye's TEA gate.
+    /wize-code-review           Adversarial peer review before Hawkeye's TEA gate
+                                (4 layers: blind, edge case, subtraction, AC audit).
+    /wize-subtract              Over-engineering-only review of a diff: ranked
+                                delete-list (delete / stdlib / native / yagni /
+                                shrink) + the net lines saved. Also a review layer.
+    /wize-debt                  Harvest every deliberate `wize-debt:` shortcut
+                                (ceiling + upgrade path) into one ledger, so a
+                                deferral can't quietly become permanent.
     /wize-party-mode            Wizer convenes multi-persona for hard calls.
 ```
 
@@ -272,6 +280,7 @@ npx wize-dev-kit version-check [--json]  # installed vs latest (cached; scriptab
 - [ELI5](https://github.com/dreambigou/eli5) by Andrew Ou — audience-calibrated explanations; the inspiration for `/wize-eli5`.
 - [No AI Slop](https://github.com/petergyang/no-ai-slop) by Peter Yang — writing hygiene that removes AI-slop patterns without flattening the writer's voice; the inspiration for `/wize-no-ai-slop` (Peggy Carter & Mantis apply it to end-user-facing prose).
 - [awesome-copilot's apple-appstore-reviewer](https://github.com/github/awesome-copilot/blob/main/skills/apple-appstore-reviewer/SKILL.md) — reviewer-mindset audit for App Store submission; the inspiration for `wize-app-store-review` (the app-overlay publication gate).
+- [Ponytail](https://github.com/DietrichGebert/ponytail) by Dietrich Gebert — deletion-first review (`/wize-subtract`), the `wize-debt:` shortcut marker and its ledger, and the measured "less code" framing behind the retrospective's code accounting. The kit's reuse ladder shares its rungs.
 
 Wize Development Kit is an **independent adaptation** — not affiliated with or endorsed by BMAD or WDS authors. Marvel persona names are used as creative references under nominative fair use.
 

package/README.pt-BR.md

@@ -69,12 +69,13 @@ Após instalar, abra sua IDE e diga:
 
 ## Harnesses suportadas
 
-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.
+Os 12 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 |
 |---|---|---|
 | **OpenCode** 🆕 | `.opencode/agents/` + `.opencode/commands/` | `mode: primary\|subagent` nativo; commands se ligam à persona dona (`agent:`); workers de fan-out rodam isolados (`subtask: true`). [Docs →](docs/harnesses/opencode.pt-BR.md) |
 | **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) |
+| **GitHub Copilot** 🆕 | `.github/skills/*/SKILL.md` + `.github/agents/*.agent.md` | Agent Skills standard para workflows/skills, **custom agents** para as 10 personas (selecionáveis na dropdown do chat); contexto always-on via `AGENTS.md`; funciona no cloud agent, code review, CLI, app e agent mode do VS Code/JetBrains. [Docs →](docs/harnesses/copilot.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) |
@@ -172,7 +173,14 @@ Transversais:
     /wize-correct-course        Re-planeja quando um gate falha ou o loop trava
                                 (auto-disparado pela guarda de max-cycles; também
                                 manual).
-    /wize-code-review           Revisão adversarial antes do gate TEA do Hawkeye.
+    /wize-code-review           Revisão adversarial antes do gate TEA do Hawkeye
+                                (4 camadas: cega, casos-limite, subtração, auditoria de AC).
+    /wize-subtract              Revisão de diff focada só em over-engineering: lista
+                                de cortes (delete / stdlib / native / yagni / shrink)
+                                + o total de linhas economizáveis. Também é uma camada.
+    /wize-debt                  Colhe todo atalho deliberado marcado com `wize-debt:`
+                                (teto + caminho de upgrade) num ledger único, para que
+                                "depois" não vire "nunca".
     /wize-party-mode            Wizer reúne multi-persona para decisões difíceis.
 ```
 
@@ -274,6 +282,8 @@ npx wize-dev-kit version-check [--json]  # instalada vs. mais recente (com cache
 - [Whiteport Design Studio expansion](https://github.com/bmad-code-org/bmad-method-wds-expansion) — metodologia UX-first, panteão nórdico (Saga, Freya), estrutura de fases.
 - [No AI Slop](https://github.com/petergyang/no-ai-slop) por Peter Yang — higiene de escrita que elimina padrões de AI slop sem achatar a voz do autor; a inspiração para `/wize-no-ai-slop`.
 - [apple-appstore-reviewer (awesome-copilot)](https://github.com/github/awesome-copilot/blob/main/skills/apple-appstore-reviewer/SKILL.md) — auditoria com mentalidade de reviewer para submissão na App Store; a inspiração para `wize-app-store-review` (gate de publicação do overlay de app).
+- [ELI5](https://github.com/dreambigou/eli5) por Andrew Ou — explicações calibradas ao ouvinte; inspiração do `/wize-eli5`.
+- [Ponytail](https://github.com/DietrichGebert/ponytail) por Dietrich Gebert — revisão orientada a deleção (`/wize-subtract`), o marcador de atalho `wize-debt:` com seu ledger, e o enquadramento medido de "menos código" por trás da contabilidade de código da retrospectiva. A reuse ladder do kit compartilha os mesmos degraus.
 
 O Wize Development Kit é uma **adaptação independente** — não afiliada nem endossada pelos autores do BMAD ou do WDS. Os nomes de personas Marvel são referências criativas sob uso nominativo justo.
 

package/adapters/README.md

@@ -7,6 +7,7 @@ Each adapter renders the kit's agents/skills/workflows into the file layout that
 | Code | Target path in repo | File format | Notes |
 |---|---|---|---|
 | `claude-code` | `.claude/skills/wize-*/` | `SKILL.md` per agent/workflow | Default. Uses Claude Code skill folder pattern. |
+| `copilot` | `.github/skills/wize-*/` + `.github/agents/wize-*.agent.md` | `SKILL.md` per workflow/skill + `.agent.md` per persona | GitHub Copilot — Agent Skills standard for skills, custom agents for personas. |
 | `cursor` | `.cursor/rules/wize-*.mdc` | MDC | Each agent/skill becomes a rule file. |
 | `windsurf` | `.windsurf/rules/wize-*.md` | Markdown | Cascade-friendly. |
 | `codex` | `.agents/skills/wize-*/` | `SKILL.md` per agent/workflow | OpenAI Codex. |

package/adapters/copilot/README.md

@@ -0,0 +1,54 @@
+# GitHub Copilot — Wize Dev Kit Adapter
+
+Emits the kit's assets into the two trees GitHub Copilot reads, mirroring how
+Copilot itself separates **skills** from **agents**:
+
+- `.github/skills/wize-{code}/SKILL.md` — workflows + skills, as **agent skills**
+  (Agent Skills standard: one folder per skill, `SKILL.md` with `name` +
+  `description` frontmatter, optional companion files).
+- `.github/agents/wize-{code}.agent.md` — the 10 personas, as **custom agents**
+  (frontmatter: `name`, `description`; body = the persona).
+
+## How Copilot picks these up
+
+- **Skills** work with the Copilot cloud agent, Copilot code review, the GitHub
+  Copilot CLI, the Copilot app, and agent mode in VS Code, JetBrains IDEs,
+  Eclipse and Xcode. Copilot discovers project skills in `.github/skills/`,
+  `.claude/skills/` or `.agents/skills/` — this adapter writes the canonical
+  `.github/skills/` path, so it also works without picking the Claude Code or
+  Codex target.
+- **Custom agents** surface in the agent dropdown (VS Code, JetBrains, and the
+  agents tab on github.com). VS Code detects any `.md` under `.github/agents/`
+  as a custom agent; GitHub's cloud agent uses the same folder. `tools` is
+  intentionally omitted so each persona keeps every available tool — the persona
+  body defines the role, and narrowing tools is a per-team decision.
+- **Progressive disclosure:** only `name` + `description` load at session start;
+  the full `SKILL.md` activates when your request matches the description (or is
+  invoked explicitly). The kit's descriptions are written keyword-rich for
+  exactly this match.
+- **Always-on instructions are not duplicated.** Copilot reads the root
+  `AGENTS.md` as agent instructions (nearest file in the tree wins), and the
+  generic adapter already emits it — including the code ladder and the kit's
+  operating contract. Writing a `.github/copilot-instructions.md` with the same
+  content would only fork it.
+- **No prompt files.** `.github/prompts/*.prompt.md` is deprecated by VS Code
+  (the migration path is *prompt → agent skill*), so this adapter ships skills
+  instead of prompts on purpose.
+- 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 GitHub's own guidance.
+
+## Files
+
+- `render.js` — personas → `.github/agents/`; workflows + skills → `.github/skills/`
+  via the shared `renderAnthropicSkills` emitter (`kinds` filter), which also
+  copies companion files (`steps/`, `templates/`, `data/`, `*.csv`) so
+  micro-file workflows resolve their relative paths.
+- `adapter.yaml` — descriptor (target path, file pattern).
+
+## Headless
+
+`copilot -p "<prompt>"` runs a one-shot session (the installer's brownfield
+baseline uses this when the Copilot CLI is the detected harness). For unattended
+automation add the minimum permissions you need, e.g. `--allow-tool=write`
+instead of `--allow-all`.

package/adapters/copilot/adapter.yaml

@@ -0,0 +1,8 @@
+code: copilot
+description: "GitHub Copilot — agent skills (.github/skills/, Agent Skills standard) + custom agents (.github/agents/*.agent.md)."
+target_path: ".github/"
+file_pattern: "skills/wize-*/SKILL.md + agents/wize-*.agent.md"
+file_format: markdown
+hooks:
+  pre_render: []
+  post_render: []

package/adapters/copilot/render.js

@@ -0,0 +1,77 @@
+// GitHub Copilot adapter — emits two trees, mirroring how Copilot itself
+// separates skills from agents:
+//
+//   - .github/skills/wize-{code}/SKILL.md    workflows + skills → agent skills
+//   - .github/agents/wize-{code}.agent.md    personas → custom agents
+//
+// GitHub Copilot reads project agent skills from .github/skills/, .claude/skills/
+// or .agents/skills/ (Agent Skills standard: a folder per skill, SKILL.md with
+// `name` + `description` frontmatter, optional companion files), and custom
+// agents from .github/agents/*.agent.md. Both paths are honored by agent mode
+// in VS Code, the Copilot cloud agent on github.com, Copilot code review, the
+// GitHub Copilot CLI and the Copilot app.
+//
+// Always-on instructions are NOT duplicated here: Copilot reads the root
+// AGENTS.md (generated by the generic adapter) as agent instructions, so
+// writing a .github/copilot-instructions.md would only fork the same content.
+//
+// Skills: https://docs.github.com/en/copilot/concepts/agents/about-agent-skills
+// Agents: https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-cloud-agent/create-custom-agents
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  collectAssets,
+  renderAnthropicSkills,
+  escapeYamlDouble,
+  clipOneLine,
+  ensureDir
+} = require('../../tools/installer/render-shared.js');
+
+function render(kitRoot, projectRoot, opts = {}) {
+  const skillsDir = path.join(projectRoot, '.github', 'skills');
+  const agentsDir = path.join(projectRoot, '.github', 'agents');
+
+  // 1. Workflows + skills → .github/skills/wize-{code}/SKILL.md
+  //    (companion files — steps/, templates/, data/ — are copied alongside by
+  //    the shared emitter so micro-file workflows resolve their relative paths.)
+  const skills = renderAnthropicSkills(kitRoot, skillsDir, { ...opts, kinds: ['workflow', 'skill'] });
+  const written = [...skills.written];
+  const skipped = [...(skills.skipped || [])];
+
+  // 2. Personas → .github/agents/wize-{code}.agent.md
+  //    Frontmatter: name (the stable wize-* identifier), description (persona
+  //    name + role + summary, shown as the chat placeholder). `tools` is left
+  //    out on purpose — the persona body defines the role, and omitting the
+  //    property grants the agent every available tool (per GitHub docs).
+  const agents = collectAssets(kitRoot, opts).filter(a => a.kind === 'agent');
+  if (!opts.dryRun) ensureDir(agentsDir);
+
+  for (const a of agents) {
+    const desc = clipOneLine(`${a.name} (${a.title}) — ${a.description}`);
+    const content = [
+      '---',
+      `name: ${a.code}`,
+      `description: "${escapeYamlDouble(desc)}"`,
+      '---',
+      '',
+      `# ${a.name} — ${a.title}`,
+      '',
+      a.body.trim(),
+      ''
+    ].join('\n');
+
+    if (opts.dryRun) {
+      written.push(`[dry-run] ${a.code}.agent.md`);
+      continue;
+    }
+    fs.writeFileSync(path.join(agentsDir, `${a.code}.agent.md`), content, 'utf-8');
+    written.push(`${a.code}.agent.md`);
+  }
+
+  return { written, skipped };
+}
+
+module.exports = { render };

package/docs/harnesses/copilot.md

@@ -0,0 +1,65 @@
+# GitHub Copilot — Wize Development Kit
+
+🌐 **Languages:** **English** · [Português (pt-BR)](copilot.pt-BR.md)
+
+← [Back to README](../../README.md)
+
+GitHub Copilot reads two kinds of project customizations, and the kit fills both:
+
+- **Agent skills** — `.github/skills/wize-{code}/SKILL.md`, following the open
+  [Agent Skills](https://agentskills.io) standard (a folder per skill; YAML
+  frontmatter with `name` + `description`).
+- **Custom agents** — `.github/agents/wize-{code}.agent.md`, one per persona,
+  with the persona as its prompt.
+
+## Output
+
+```
+.github/
+├── agents/     wize-orchestrator.agent.md, wize-agent-dev.agent.md, … (10 personas)
+└── skills/     wize-grill/SKILL.md, wize-code-review/SKILL.md, … (workflows + skills)
+```
+
+Companion files (`steps/`, `templates/`, `data/`, `*.csv`) are copied next to
+each `SKILL.md`, so micro-file workflows like `wize-create-architecture` resolve
+their relative paths.
+
+## Notable
+
+- **Where it works.** Copilot cloud agent, Copilot code review, the GitHub
+  Copilot CLI, the Copilot app, and agent mode in VS Code, JetBrains IDEs,
+  Eclipse and Xcode. Copilot discovers project skills in `.github/skills/`,
+  `.claude/skills/` or `.agents/skills/` — this adapter writes the canonical
+  `.github/skills/` path.
+- **Progressive disclosure.** Only `name` + `description` load at session start;
+  the full `SKILL.md` activates when your request matches the description. The
+  kit's descriptions are keyword-rich on purpose.
+- **Always-on context comes from `AGENTS.md`.** Copilot treats `AGENTS.md` as
+  agent instructions (the nearest file in the directory tree wins), and the
+  installer already generates one — carrying the operating contract **and** the
+  code ladder (YAGNI → reuse → stdlib → native → installed dependency →
+  one-liner → minimum). No `.github/copilot-instructions.md` duplicate is
+  written; keep your own there if you need repo-specific rules beyond the kit's.
+- **The personas are pickable.** The agent dropdown (VS Code / JetBrains) and
+  the agents tab on github.com list the 10 `wize-*` agents, each with its role
+  as description. `tools` is omitted, so a persona keeps every available tool.
+- **No prompt files.** `.github/prompts/*.prompt.md` is deprecated by VS Code
+  (migrating to agent skills), so the kit ships skills instead — `/wize-{code}`
+  invocations are covered by skill activation.
+
+## Setup
+
+Pick **GitHub Copilot** as an IDE target during `npx wize-dev-kit install` (or
+add it and re-run `npx wize-dev-kit sync`). Restart Copilot, then start with
+`/wize-orchestrator` in chat — or select a persona from the agent dropdown.
+
+Generated `wize-*` files are gitignored (regenerate any time with
+`npx wize-dev-kit sync`). Hand-written team skills added next to them should be
+committed.
+
+## Headless
+
+`copilot -p "<prompt>"` runs a one-shot session without entering the interactive
+UI, which is what the installer's brownfield baseline uses when the Copilot CLI
+is the detected harness. For unattended automation, grant the minimum you need
+(for example `--allow-tool=write`) rather than `--allow-all`.

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

@@ -0,0 +1,65 @@
+# GitHub Copilot — Wize Development Kit
+
+🌐 **Idiomas:** [English](copilot.md) · **Português (pt-BR)**
+
+← [Voltar ao README](../../README.pt-BR.md)
+
+O GitHub Copilot lê dois tipos de customização de projeto, e o kit preenche os dois:
+
+- **Agent skills** — `.github/skills/wize-{code}/SKILL.md`, seguindo o padrão aberto
+  [Agent Skills](https://agentskills.io) (uma pasta por skill; frontmatter YAML com
+  `name` + `description`).
+- **Custom agents** — `.github/agents/wize-{code}.agent.md`, um por persona, com a
+  persona como prompt.
+
+## Saída
+
+```
+.github/
+├── agents/     wize-orchestrator.agent.md, wize-agent-dev.agent.md, … (10 personas)
+└── skills/     wize-grill/SKILL.md, wize-code-review/SKILL.md, … (workflows + skills)
+```
+
+Arquivos companheiros (`steps/`, `templates/`, `data/`, `*.csv`) são copiados ao
+lado de cada `SKILL.md`, então workflows micro-file como `wize-create-architecture`
+resolvem seus caminhos relativos.
+
+## Destaques
+
+- **Onde funciona.** Copilot cloud agent, Copilot code review, GitHub Copilot CLI,
+  app do Copilot e agent mode no VS Code, JetBrains IDEs, Eclipse e Xcode. O Copilot
+  descobre skills de projeto em `.github/skills/`, `.claude/skills/` ou
+  `.agents/skills/` — este adapter escreve o caminho canônico `.github/skills/`.
+- **Progressive disclosure.** No início da sessão só `name` + `description` são
+  carregados; o `SKILL.md` completo ativa quando o pedido casa com a descrição. As
+  descrições do kit são ricas em palavras-chave de propósito.
+- **Contexto always-on vem do `AGENTS.md`.** O Copilot trata `AGENTS.md` como
+  instruções de agente (o arquivo mais próximo na árvore vence), e o installer já
+  gera um — carregando o contrato de operação **e** a ladder de código
+  (YAGNI → reuso → stdlib → nativo → dependência instalada → uma linha → mínimo).
+  Nenhum `.github/copilot-instructions.md` duplicado é escrito; mantenha o seu ali
+  se precisar de regras específicas do repo além das do kit.
+- **As personas são selecionáveis.** A dropdown de agentes (VS Code / JetBrains) e a
+  aba de agentes no github.com listam os 10 agentes `wize-*`, cada um com seu papel
+  na descrição. O campo `tools` é omitido, então cada persona mantém todas as
+  ferramentas disponíveis.
+- **Sem prompt files.** `.github/prompts/*.prompt.md` está deprecado pelo VS Code
+  (migrando para agent skills), então o kit entrega skills — as invocações
+  `/wize-{code}` ficam cobertas pela ativação por descrição.
+
+## Instalação
+
+Escolha **GitHub Copilot** como IDE target no `npx wize-dev-kit install` (ou
+adicione e rode `npx wize-dev-kit sync`). Reinicie o Copilot e comece com
+`/wize-orchestrator` no chat — ou selecione uma persona na dropdown de agentes.
+
+Arquivos `wize-*` gerados ficam no `.gitignore` (regenere com
+`npx wize-dev-kit sync`). Skills de time escritas à mão ao lado deles devem ser
+commitadas.
+
+## Headless
+
+`copilot -p "<prompt>"` roda uma sessão one-shot sem entrar na UI interativa — é o
+que o baseline brownfield do installer usa quando o Copilot CLI é o harness
+detectado. Para automação não assistida, conceda o mínimo necessário (por exemplo
+`--allow-tool=write`) em vez de `--allow-all`.

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "wize-dev-kit",
-  "version": "0.20.0",
+  "version": "0.22.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/core-skills/module.yaml

@@ -31,10 +31,16 @@ skills:
   - code: wize-review-adversarial
     name: "Adversarial Review"
     description: "Red-team review of artifacts — challenges assumptions, surfaces edge cases."
+  - code: wize-subtract
+    name: "Subtract"
+    description: "Over-engineering-only review of a diff: what to delete, simplify, or replace with stdlib/native — ranked delete-list plus the net lines saved."
   - code: wize-spec
     name: "Spec"
     description: "Distills any intent input into a canonical five-field spec kernel + companions."
   - code: wize-pre-pr-check
     name: "Pre-PR Check"
     description: "Quando for abrir um Pull Request ou PR leia — gate local para lint, format, build e testes rápidos antes de submeter código."
+  - code: wize-debt
+    name: "Debt Ledger"
+    description: "Harvests every deliberate `wize-debt:` shortcut (ceiling + upgrade path) into one ledger so deferrals don't rot into \"never\"."
 

package/src/core-skills/wize-debt/skill.md

@@ -0,0 +1,89 @@
+---
+
+code: wize-debt
+description: "Use quando precisar colher os atalhos deliberados espalhados no código (marcadores wize-debt:) num ledger único, para que o adiamento não vire esquecimento permanente."
+name: Debt Ledger
+module: core
+status: ready
+---
+
+# Debt Ledger
+
+**Goal.** Every deliberate shortcut with a known ceiling is marked in code as a `wize-debt:` comment naming its ceiling and its upgrade path. This skill harvests every marker into one ledger, so a deferral can't quietly become permanent.
+
+Reads and reports. Changes nothing.
+
+## When to run
+
+- Before the retrospective (`wize-retrospective`) — the debt marker count is a sprint metric.
+- Before a release (`wize-release`).
+- When the user says "what did we defer", "list the shortcuts", "debt ledger", "what's marked wize-debt", "/wize-debt".
+
+## The marker
+
+```js
+// wize-debt: single-threaded — upgrade to a queue when the second worker lands
+```
+
+```
+# wize-debt: O(n²) scan — index it if the list passes ~10k rows
+```
+
+- **ceiling** — the limit we knowingly accepted (global lock, O(n²) scan, naive heuristic, in-memory only, retry-less call).
+- **upgrade path** — the trigger to revisit. Prefer an **event or threshold** ("when the second worker lands", "if rows pass 10k") over a date — a date rots silently.
+
+A deliberate shortcut **without** a marker is the real problem: nobody remembers it. Vague TODOs (`// TODO: improve this`) are not a ceiling and not an upgrade path — they are noise, and they do not belong in the ledger.
+
+## Steps
+
+### 1. Scan
+
+Grep the repo for the marker, skipping `node_modules`, `.git`, build output and vendored code:
+
+```bash
+grep -rnE '(#|//|<!--|/\*|--) ?wize-debt:' . \
+  --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=dist --exclude-dir=build
+```
+
+Each hit is one ledger row. The `wize-debt:` prefix keeps prose that merely mentions the convention out of the ledger.
+
+### 2. Build the ledger
+
+One row per marker, grouped by file:
+
+```
+<file>:L<line> — <what was simplified>. ceiling: <limit>. upgrade: <trigger>.
+```
+
+Optional owner per row, when the user asks for one:
+
+```bash
+git blame -L<line>,<line> --date=short -- <file> | head -1
+```
+
+### 3. Flag the rot
+
+Any marker that names no trigger gets the tag `no-trigger`. Those are the ones that silently rot — say so explicitly rather than hiding them in the list.
+
+### 4. Report
+
+End with the count:
+
+```
+<N> markers, <M> no-trigger.
+```
+
+Nothing found: `Clean ledger — no wize-debt markers.`
+
+Write it to `.wize/implementation/debt.md` **only when asked**; otherwise it is a one-shot report in the conversation.
+
+## Rules
+
+- **Read-only.** Never edits the code, never removes a marker, never "fixes" one. Revisiting a ceiling is a separate change with its own review.
+- **A marker is not a TODO.** The ledger tracks shortcuts with a named ceiling and trigger. Missing behavior, unfinished work, or "improve later" notes are not debt rows.
+- **`no-trigger` markers are the finding.** A ceiling with no upgrade path is the definition of rot — surface it, don't normalize it.
+- **Skip generated and vendored code.** Markers in `dist/`, `node_modules/`, or vendored trees are noise.
+
+## Hand-off
+
+> Debt ledger complete. `<N>` marker(s), `<M>` no-trigger. Next: feed the count into `wize-retrospective`, or fix a ceiling via `wize-quick-dev`.

package/src/core-skills/wize-subtract/skill.md

@@ -0,0 +1,91 @@
+---
+
+code: wize-subtract
+description: "Use quando um diff ou PR precisar de revisão focada em over-engineering — o que dá para deletar, simplificar ou trocar por stdlib/nativo, com a lista de cortes e o total de linhas economizáveis."
+name: Subtract
+module: core
+status: ready
+---
+
+# Subtract
+
+**Goal.** Review a diff with one lens only: **unnecessary complexity**. Answer the question the other review layers don't ask — *what can be deleted, and what replaces it?* The best outcome for a diff is that it gets shorter.
+
+This complements `wize-code-review` (correctness, edge cases, acceptance criteria) and `wize-tea-review` (AC fulfillment). Subtract hunts bloat. It **lists** findings; it does not apply them.
+
+## When to run
+
+- Before opening a PR, once the diff is complete.
+- As the **Subtraction Hunter** layer inside `wize-code-review` (runs on every code PR).
+- When the user says "review for over-engineering", "what can we delete", "is this too much code", "simplify this", "/wize-subtract".
+
+## When NOT to run
+
+- As a replacement for correctness or security review — those are out of scope here.
+- On generated code, vendored code, or lockfiles.
+- When the diff is already minimal: say so and stop (see "Clean diff").
+
+## Inputs
+
+- The diff (PR, branch, commit range, or staged changes).
+- Read access to the codebase — reuse claims must be verified, not guessed.
+
+## Output
+
+One line per finding, ranked by lines saved (biggest cut first):
+
+```
+path/to/file:L<line>: <tag> <what to cut>. <what replaces it>.
+```
+
+Tags:
+
+- `delete:` — dead code, unused flexibility, speculative feature. Replacement: nothing.
+- `stdlib:` — a hand-rolled thing the standard library ships. Name the function.
+- `native:` — a dependency or code doing what the platform/framework already does. Name the feature.
+- `yagni:` — an abstraction with one implementation, config nobody sets, a layer with one caller.
+- `shrink:` — same logic, fewer lines. Show the shorter form.
+
+End with the only metric that matters: `net: -<N> lines possible.`
+
+**Clean diff:** `Lean already. Ship.` and stop.
+
+## Rules
+
+- **One line per finding.** Location, what to cut, what replaces it. The review's own output obeys the ladder — no essays.
+- **Name the replacement.** "This looks complex" is not a finding. `stdlib:` must name the function; `native:` must name the feature; `yagni:`/`delete:` must name what already exists or state that nothing replaces it.
+- **Complexity only.** Correctness bugs, security holes, and performance problems are out of scope — route them to `wize-code-review`, don't smuggle them in here.
+- **Never flag the floor.** Tests on non-trivial logic are the kit's minimum, not bloat. Validation at trust boundaries, data-loss handling, security, accessibility, and anything explicitly requested are **never** on the chopping block.
+- **Verify before claiming.** "Already in this codebase" requires the existing helper/pattern to be named; "the stdlib does it" requires the function to exist in the target language/runtime.
+- **Read before cutting.** Trace the real flow the change touches. The shortest diff in the wrong place is not lazy — it's a second bug.
+- **Report only.** Do not apply the findings. Applying them is a separate, reviewable change (usually `wize-quick-dev`).
+
+## Steps
+
+### 1. Read the diff against the codebase
+
+For every hunk, know what it touches and who calls it. Claims about reuse need the surrounding code read, not recalled.
+
+### 2. Walk the ladder backwards
+
+For each hunk, stop at the first question that holds:
+
+1. Does this need to exist at all? → `delete:` (replacement: nothing).
+2. Does it duplicate something already here? → `yagni:` or `delete:`, naming the existing helper/pattern.
+3. Does the standard library do it? → `stdlib:`, naming the function.
+4. Does the platform or framework do it? → `native:`, naming the feature.
+5. Is a dependency doing one small thing? → `native:` / `shrink:`, naming what replaces it.
+6. Same logic in fewer lines? → `shrink:`, showing the shorter form.
+7. Is it configuration, an interface, or a layer with a single caller? → `yagni:`.
+
+### 3. Rank and totalize
+
+Sort by estimated lines removed (descending). Sum them: `net: -<N> lines possible.`
+
+### 4. Hand back
+
+Present the list as-is. Findings that contradict an explicit requirement or the safety floor are dropped out loud — say which and why, so the omission is visible.
+
+## Hand-off
+
+> Subtraction review complete for `{change}`. `{count}` finding(s), `net: -{N} lines possible.` Next: apply via `wize-quick-dev`, or continue to `wize-code-review` for correctness.

package/src/method-skills/4-implementation/wize-agent-dev/persona.md

@@ -11,6 +11,7 @@ I am **Shuri**. Wakandan technologist. I implement the story Tony wrote, against
 3. **Red → green → refactor.** Tests first; minimum code to pass; clean.
 4. **Security & perf.** I think about both at write-time, not at review-time.
 5. **Commit with AC IDs.** Every commit cites the story acceptance criteria it advances.
+6. **Subtract before I push.** Before opening the PR I run `/wize-subtract` on my own diff — my code climbs the ladder too, and the review's best outcome is a shorter diff.
 
 ## Before I write new code (the reuse ladder)
 
@@ -34,7 +35,7 @@ At the "green" step, before typing a new function, I walk this ladder in order a
 
 - I won't change architecture without an ADR from Tony.
 - I won't waive a Hawkeye gate without Wizer's approval logged.
-- I won't ship code with TODO comments left for someone else.
+- I won't ship a vague TODO for someone else. A **deliberate shortcut with a known ceiling** is a different thing: it gets a `wize-debt:` marker naming its ceiling and its upgrade trigger (harvested by `/wize-debt`) — or it doesn't ship.
 
 ## Quick-dev mode
 

package/src/method-skills/4-implementation/wize-code-review/steps/step-02-review.md

@@ -9,6 +9,7 @@ failed_layers: ''
 - Speak in `{communication_language}`.
 - The Blind Hunter subagent receives **only** the diff — no project context.
 - The Edge Case Hunter subagent receives the diff and project read access.
+- The Subtraction Hunter subagent receives the diff and project read access.
 - The Acceptance Auditor subagent receives the diff, spec, and context docs.
 - All review subagents run at the same model capability as the current session.
 
@@ -26,6 +27,9 @@ This step is an instance of Wizer's subagent fan-out pattern (see `wize-orchestr
    - **Edge Case Hunter** — receives `{diff_output}` and read access to the project. Invoke via `wize-review-edge-case-hunter`.
      Prompt: "Walk every branching path and boundary condition in this diff. Report only unhandled edge cases as a JSON array."
 
+   - **Subtraction Hunter** — receives `{diff_output}` and read access to the project. Invoke via `wize-subtract`.
+     Prompt: "Review this diff for over-engineering only. One line per finding: `path:L<line>: <tag> <what to cut>. <what replaces it>.` Tags: delete | stdlib | native | yagni | shrink. Rank by lines saved. End with `net: -<N> lines possible.` Never flag tests, validation, security, or accessibility."
+
    - **Acceptance Auditor** (only if `{review_mode}` = `"full"`) — receives `{diff_output}`, `{spec_file}` content, and context docs.
      Prompt: "Review this diff against the spec. Check for violations of acceptance criteria, deviations from spec intent, and missing behavior. Output findings as a Markdown list with AC/constraint reference and evidence."
 

package/src/method-skills/4-implementation/wize-code-review/steps/step-03-triage.md

@@ -10,11 +10,12 @@
 1. **Normalize** findings into a common format. Expected input formats:
    - Blind Hunter: Markdown list of descriptions.
    - Edge Case Hunter: JSON array with `location`, `trigger_condition`, `guard_snippet`, `potential_consequence`.
+   - Subtraction Hunter: Markdown list of `path:L<line>: <tag> <what to cut>. <what replaces it>.` plus a closing `net: -<N> lines possible.` Keep the tags (`delete`, `stdlib`, `native`, `yagni`, `shrink`) and the net total verbatim.
    - Acceptance Auditor: Markdown list with title, AC/constraint reference, and evidence.
 
    Convert all to a unified list with:
    - `id` — sequential integer
-   - `source` — `blind`, `edge`, `auditor`, or merged (`blind+edge`, etc.)
+   - `source` — `blind`, `edge`, `subtract`, `auditor`, or merged (`blind+edge`, etc.)
    - `title` — one-line summary
    - `detail` — full description
    - `location` — file and line reference if available
@@ -30,6 +31,11 @@
    - **defer** — pre-existing issue not caused by this change.
    - **dismiss** — noise, false positive, or handled elsewhere.
 
+   Classification of Subtraction Hunter findings:
+   - Cutting code **this diff introduced** → `patch`.
+   - Cutting pre-existing code the diff didn't touch → `defer` (record it; the change is out of scope for this PR).
+   - A cut that contradicts an explicit requirement or the safety floor (validation at trust boundaries, data-loss handling, security, accessibility, tests on non-trivial logic) → `dismiss`, and say which requirement protected it.
+
    If `{review_mode}` = `"no-spec"` and a finding would be `decision_needed`, reclassify as `patch` or `defer`.
 
 4. **Drop** all `dismiss` findings. Record the dismiss count.

package/src/method-skills/4-implementation/wize-code-review/steps/step-04-present.md

@@ -45,6 +45,8 @@ Code review complete.
 - dismissed: {R}
 ```
 
+When the Subtraction Hunter ran, add its metric on the following line: `Subtraction: {C} cut(s) proposed, net: -{N} lines possible.` Report it as a number, not a vibe — a diff that got shorter is a review outcome, not a style preference.
+
 If `{spec_file}` is set, add: "Findings written to `{spec_file}`."
 
 ### 4. Resolve decision_needed findings

package/src/method-skills/4-implementation/wize-code-review/workflow.md

@@ -57,7 +57,7 @@ This skill uses **step-file architecture**:
 ## Steps
 
 1. `step-01-gather-context.md` — identify the diff source, construct `{diff_output}`, set `{review_mode}` and `{spec_file}`.
-2. `step-02-review.md` — launch parallel review layers (Blind Hunter, Edge Case Hunter, Acceptance Auditor).
+2. `step-02-review.md` — launch parallel review layers (Blind Hunter, Edge Case Hunter, Subtraction Hunter, Acceptance Auditor).
 3. `step-03-triage.md` — normalize, deduplicate, and classify findings into `decision_needed`, `patch`, `defer`, `dismiss`.
 4. `step-04-present.md` — present findings, resolve decisions, apply patches, update story status.
 

package/src/method-skills/4-implementation/wize-retrospective/workflow.md

@@ -26,6 +26,7 @@ Wizer facilitates. Hill enforces output discipline. Everyone (including Pepper,
 - All `gate.md` files from current sprint
 - `tea/nfr/{epic}.md` if an epic closed this sprint
 - Quick-dev log
+- Git history for the sprint window (tag range, or first → last commit)
 
 ## Output
 
@@ -57,6 +58,21 @@ Wizer reads the sprint dashboard from `sprint-status.md`:
 
 Stats anchor the retro in observations, not feelings.
 
+#### Code accounting (numbers, not adjectives)
+
+Measured from git over the sprint window. Report the numbers even when they look bad — especially then:
+
+| Metric | How to get it |
+|---|---|
+| Lines added / removed / net | `git diff --shortstat <base>..<head>` (base = last sprint's tag or first commit) |
+| Files touched | count of distinct files in the range: `git diff --name-only <base>..<head> \| wc -l` |
+| Dependencies | entries added/removed in the manifest diff (`package.json`, `composer.json`, `pyproject.toml`, `Cargo.toml`) |
+| New abstractions | modules, classes, or interfaces introduced by the sprint (count from the diff) |
+| Debt markers | `wize-debt:` added vs retired this sprint (run `/wize-debt`) |
+| Complexity | cyclomatic-complexity delta from `tea/nfr/{epic}.md` when an epic closed |
+
+Why this exists: the kit's discipline (reuse ladder, `/wize-subtract`, debt markers) is only verifiable with numbers. A sprint that ships 4 stories while adding 3k net lines and 6 dependencies is telling you something — say it out loud in the retro, and turn it into a change if it repeats.
+
 ### 2. Worked / didn't / surprised
 
 Each engineer brings 2–3 items per section, written in advance ideally. Time-box discussion: any item that takes > 3 min becomes a follow-up.
@@ -98,6 +114,13 @@ attendees: [Hill, Tony, Mantis, Pepper, Fury, Hawkeye, Shuri]
 - Blockers: 1 (vendor sandbox, resolved Day 5)
 - Carry-over to S8: 0
 
+## Code accounting
+- Lines: +1.842 / −2.310 (net −468) across 71 files
+- Dependencies: +1 (`zod`), −0
+- New abstractions: 2 (one repository interface, one mapper — both with a single implementation; flagged by `/wize-subtract`)
+- Debt markers: +3 added, −1 retired (2 with a trigger, 1 `no-trigger`)
+- Complexity: no NFR delta this sprint (no epic closed)
+
 ## Worked
 - Pairing on E03-S02 (auth refresh) — issue caught at integration test instead of in prod.
 - TEA design done at planning for R-3 stories paid off.

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

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+// Verifica que as skills core (wize-subtract, wize-debt, wize-eli5) são
+// renderizadas por TODOS os 12 adapters de harness.
+//
+// Uso:
+//   node tools/check-skills-all-adapters.js            # valida a lista padrão
+//   node tools/check-skills-all-adapters.js wize-grill # valida skills específicas
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const KIT = path.resolve(__dirname, '..');
+
+// Skill code -> { dir, marker } — `dir` é o diretório esperado dentro de cada
+// adapter e `marker` a string que precisa aparecer no arquivo renderizado.
+const SKILLS = {
+  'wize-subtract': { dir: 'wize-subtract', marker: 'Subtraction Hunter' },
+  'wize-debt':     { dir: 'wize-debt',     marker: 'wize-debt:' },
+  'wize-eli5':     { dir: 'wize-eli5',     marker: 'Explain Like I Am 5' },
+};
+
+// Onde cada harness deposita uma skill `wize-{code}`.
+const ADAPTERS = [
+  { code: 'claude-code', path: (c) => `.claude/skills/${c}/SKILL.md` },
+  { code: 'copilot',     path: (c) => `.github/skills/${c}/SKILL.md` },
+  { code: 'antigravity', path: (c) => `.agent/skills/${c}/SKILL.md` },
+  { code: 'codex',       path: (c) => `.agents/skills/${c}/SKILL.md` },
+  { code: 'kimi-code',   path: (c) => `.kimi/skills/${c}/SKILL.md` },
+  { code: 'hermes',      path: (c) => `.hermes/skills/${c}/SKILL.md` },
+  { code: 'kiro',        path: (c) => `.kiro/skills/${c}/SKILL.md` },
+  { code: 'cursor',      path: (c) => `.cursor/rules/${c}.mdc` },
+  { code: 'windsurf',    path: (c) => `.windsurf/rules/${c}.md` },
+  { code: 'continue',    path: (c) => `.continue/prompts/${c}.prompt` },
+  { code: 'opencode',    path: (c) => `.opencode/commands/${c}.md` },
+  { code: 'generic',     path: (c) => `.wize/agents/${c}.md` },
+];
+
+const requested = process.argv.slice(2);
+const targets = requested.length ? requested : Object.keys(SKILLS);
+for (const code of targets) {
+  if (!SKILLS[code]) {
+    console.error(`Skill desconhecida: ${code}. Conhecidas: ${Object.keys(SKILLS).join(', ')}`);
+    process.exit(2);
+  }
+}
+
+let ok = 0, fail = 0;
+
+for (const skill of targets) {
+  const { marker } = SKILLS[skill];
+  console.log(`\n${skill} (marcador: "${marker}")`);
+
+  for (const a of ADAPTERS) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), `wize-${skill}-${a.code}-`));
+    try {
+      const mod = require(path.join(KIT, 'adapters', a.code, 'render.js'));
+      mod.render(KIT, root, { profiles: ['core'] });
+      const rel = a.path(skill);
+      const f = path.join(root, rel);
+      if (!fs.existsSync(f)) {
+        console.log(`  ✖ ${a.code.padEnd(11)} -> ${rel} NÃO foi gerado`);
+        fail++;
+        continue;
+      }
+      const content = fs.readFileSync(f, 'utf-8');
+      // O corpo da skill é o que precisa estar lá; o código `wize-{skill}` só
+      // aparece no frontmatter, que não é copiado por todos os adapters
+      // (cursor/windsurf/opencode/generic não carregam o code no arquivo).
+      if (content.includes(marker)) {
+        console.log(`  ✓ ${a.code.padEnd(11)} -> ${rel}`);
+        ok++;
+      } else {
+        console.log(`  ✖ ${a.code}: ${rel} existe mas não contém o corpo esperado ("${marker}")`);
+        fail++;
+      }
+    } catch (e) {
+      console.log(`  ✖ ${a.code}: erro ao renderizar — ${e.message}`);
+      fail++;
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  }
+}
+
+const total = targets.length * ADAPTERS.length;
+console.log(`\n${ok}/${total} renderizações OK (${targets.length} skill(s) × ${ADAPTERS.length} harnesses).`);
+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 > kiro-cli (universal fallback)
+//   2. claude > copilot > 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.
@@ -26,6 +26,11 @@ const HARNESSES = [
     binary: 'claude',
     buildCmd: (prompt) => ({ cmd: 'claude', args: ['-p', prompt] })
   },
+  {
+    code: 'copilot',
+    binary: 'copilot',
+    buildCmd: (prompt) => ({ cmd: 'copilot', args: ['-p', prompt] })
+  },
   {
     code: 'codex',
     binary: 'codex',
@@ -106,7 +111,7 @@ function manualInstructions(harness) {
   if (!harness) {
     return [
       '',
-      'No AI harness CLI was detected on PATH (claude / codex / opencode / hermes / kiro-cli).',
+      'No AI harness CLI was detected on PATH (claude / copilot / codex / opencode / hermes / kiro-cli).',
       'Open your IDE in this repo and run:',
       '  /wize-document-project',
       ''

package/tools/installer/commands/doctor.js

@@ -57,6 +57,7 @@ function adapterTargetPath(targetCode, projectRoot) {
   // Mirror of the adapter render conventions documented in adapters/README.md.
   switch (targetCode) {
     case 'claude-code':  return path.join(projectRoot, '.claude/skills');
+    case 'copilot':      return path.join(projectRoot, '.github/skills');
     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');

package/tools/installer/render-shared.js

@@ -211,8 +211,12 @@ function collectAssets(kitRoot, { profiles = ['core'] } = {}) {
 
 // Anthropic-style SKILL.md renderer used by Claude Code, Antigravity, Codex, Kimi.
 // Each asset becomes <targetDir>/<code>/SKILL.md with YAML frontmatter (name, description).
+// `opts.kinds` (optional) restricts the emitter to some asset kinds — GitHub
+// Copilot uses it to send workflows/skills to .github/skills/ while its personas
+// go out as .agent.md custom agents instead.
 function renderAnthropicSkills(kitRoot, targetDir, opts = {}) {
-  const assets = collectAssets(kitRoot, opts);
+  const kinds = opts.kinds ? new Set(opts.kinds) : null;
+  const assets = collectAssets(kitRoot, opts).filter(a => !kinds || kinds.has(a.kind));
   const written = [];
   if (!opts.dryRun) ensureDir(targetDir);
 
@@ -303,6 +307,34 @@ function renderAgentsMd(kitRoot, projectRoot, opts = {}) {
     'implementation and review, a high-capability tier only for architecture, critical',
     'decisions, or final adversarial review.',
     '',
+    '## Writing code (always on)',
+    '',
+    'Before writing new code, climb this ladder and stop at the first rung that holds:',
+    '',
+    '1. Does this need to exist? → no: skip it (YAGNI).',
+    '2. Already in this codebase? → reuse the helper, util, or pattern; don\'t rewrite it.',
+    '3. Does the standard library do it? → use it.',
+    '4. Does a platform or framework feature cover it? → use it.',
+    '5. Does an already-installed dependency solve it? → use it.',
+    '6. Is it one line? → write the one line.',
+    '7. Only then: the minimum code that works.',
+    '',
+    'The ladder runs **after** you understand the problem: read the code the change touches and',
+    'trace the real flow before picking a rung.',
+    '',
+    '- No abstractions, configuration, or boilerplate nobody asked for. No new dependency if it can be avoided.',
+    '- Deletion over addition. Boring over clever. Fewest files possible.',
+    '- Bug fix = root cause, not symptom: grep every caller of the function you touch and fix the shared function once.',
+    '- The shortest working diff wins — but only once you understand the problem.',
+    '',
+    'Lazy, not negligent — never on the chopping block: input validation at trust boundaries,',
+    'error handling that prevents data loss, security, accessibility, tests on non-trivial logic,',
+    'and anything explicitly requested.',
+    '',
+    'A deliberate shortcut with a known ceiling gets a `wize-debt:` comment naming the ceiling and',
+    'the upgrade trigger, so it can be harvested later with `/wize-debt`. Before a PR, run',
+    '`/wize-subtract` on the diff — the best review outcome is a shorter diff.',
+    '',
     '## Roster',
     ''
   ];

package/tools/installer/setup-helpers.js

@@ -21,6 +21,8 @@ const GITIGNORE_BODY = [
   '',
   '# Generated IDE adapter outputs (regenerate with `npx wize-dev-kit install`)',
   '.claude/skills/wize-*',
+  '.github/skills/wize-*',
+  '.github/agents/wize-*.agent.md',
   '.agent/skills/wize-*',
   '.agents/skills/wize-*',
   '.kimi/skills/wize-*',

package/tools/installer/validators/run-all.js

@@ -28,6 +28,14 @@ function checkWorkflow(file) {
   if (!/^name:/m.test(content))      errs.push('missing "name:"');
   if (!/^owner:/m.test(content) && !/^module:/m.test(content)) errs.push('missing "owner:" or "module:"');
   if (!/^description:/m.test(content)) errs.push('missing "description:"');
+  // The kit's parser (readFrontmatter) reads a double-quoted scalar with
+  // /^"([^"]*)"$/, so an escaped quote inside the value (\" or \') breaks it:
+  // the value is parsed with its wrapping quotes and re-escaped on render.
+  // Write descriptions without inner quotes instead.
+  const dm = content.match(/^description:\s*"(.*)"\s*$/m);
+  if (dm && /\\["']/.test(dm[1])) {
+    errs.push('description contains escaped quotes (\\" or \\\') — the kit parser does not support them; rewrite without quotes');
+  }
   return errs;
 }
 

package/tools/installer/wize-cli.js

@@ -33,6 +33,7 @@ const KIT_VERSION = require(path.join(KIT_ROOT, 'package.json')).version;
 
 const TARGETS = [
   { code: 'claude-code', label: 'Claude Code (.claude/skills/)', default: true },
+  { code: 'copilot', label: 'GitHub Copilot (.github/skills/ + .github/agents/)', default: false },
   { code: 'cursor', label: 'Cursor (.cursor/rules/)', default: false },
   { code: 'windsurf', label: 'Windsurf', default: false },
   { code: 'codex', label: 'Codex', default: false },