@eltonssouza/development-utility-kit 0.10.0

package/.claude/skills/quick-feature/SKILL.md

@@ -0,0 +1,266 @@
+---
+name: quick-feature
+description: Fast-lane for small/medium features that don't justify the full grill-me → to-prd → to-issues → analyst → run-sprint pipeline. Use when the requirement is concrete enough that a 5-question discovery interview would be friction, not value. Examples: "add a new field to the Product DTO", "fix the search to be case-insensitive", "create endpoint to export sales as CSV", "add pagination to the orders list", "add a confirm dialog before delete". Triggers on "quick feature", "atalho", "fast-lane", "feature pequena", "ajuste rápido", "small feature", "tarefa pequena". Generates a minimal PLAN_*.md (1 sprint, 1-3 tasks, goal-ready DoD) directly from the user's description — no discovery, no PRD, no issues — and hands off to run-sprint. Do NOT use for new bounded contexts, new domain concepts, cross-cutting refactors, or features requiring architectural decisions (those still need grill-me + analyst + ADR). Do NOT use to skip the senior+ gate — gate-keeper still runs at end-of-task. PT triggers: 'feature rápida', 'tarefa pequena', 'ajuste rápido', 'pula a entrevista', 'só vai e faz', 'quick feature', 'atalho'.
+tools: Read, Write, Edit, Glob, Grep
+model: sonnet
+---
+
+# Quick Feature — Fast-lane for small features
+
+> **Bypass authorized only for low-risk, well-scoped work.** The full pipeline (`grill-me → to-prd → to-issues → analyst → run-sprint`) exists to surface hidden requirements and force discovery. For small features where the requirement is already concrete, that pipeline is friction. This skill is the audited bypass: it generates a minimal PLAN, dispatches `run-sprint`, and lets `gate-keeper` do its job at the end.
+
+Always respond in American English.
+
+---
+
+## 1. When to trigger
+
+- "quick feature: <description>"
+- "atalho: <descrição>"
+- "feature pequena: <X>", "tarefa pequena: <X>", "ajuste rápido"
+- "pula a entrevista, é simples"
+- "só vai e faz: <X>"
+- "small feature", "fast-lane"
+- Examples that fit:
+  - "add a new field `description` to ProductRequest DTO with validation"
+  - "fix the product search to be case-insensitive"
+  - "add CSV export to the sales list page"
+  - "add a confirmation dialog before deleting an order"
+  - "expose a new GET endpoint that returns count by status"
+
+## 2. When NOT to trigger
+
+This skill is **NOT** for:
+
+- **New bounded context** or new domain concept → `grill-me` + `to-prd` + `analyst` (full pipeline).
+- **Cross-cutting refactor** (changing pattern, splitting monolith, redesigning API) → `tech-lead` + ADR.
+- **Architectural decision** (Kafka vs SQS, Hexagonal vs Clean, new lib choice) → `tech-lead` + ADR.
+- **Feature touching > 5 files or > 2 bounded contexts** → use full pipeline; it's not small.
+- **Ambiguous requirements** (you can phrase 3+ different things from the prompt) → `grill-me` instead.
+- **Bug in production** → `pair-debug` (hypothesis-driven), not this.
+- **Performance regression without clear cause** → `pair-debug` + `tech-lead`.
+
+When in doubt → full pipeline. Bypass exists for clear cases; ambiguity is the signal to NOT bypass.
+
+## 3. Flow
+
+### Step 1 — Confirm scope is "small"
+
+Apply the 4-question sanity check (silent, do not ask the user):
+
+1. Is the requirement concrete enough to phrase as a single user story?
+2. Does it touch ≤ 5 files in a single bounded context?
+3. Does it NOT require an ADR (no pattern change, no new dependency)?
+4. Are inputs/outputs/validation already implied by existing code patterns?
+
+If any answer is **no**, **stop and instruct** the user to use the full pipeline (`grill me sobre <X>`). Do not generate the PLAN.
+
+### Stage 0 — Stack pre-resolution (per ADR-026 Layer 1)
+
+> **MANDATORY after Step 1 sanity check passes and BEFORE Step 2 grounding.** Resolves the project's stack so every downstream dispatch (`sprint-runner` → developers, `qa-engineer`, `gate-keeper`) receives the correct knowledge pack inline in its prompt. Avoids re-resolution in `run-sprint` (optimization: resolve once, propagate).
+
+Steps:
+
+a) Invoke `stack-resolver` via Task tool:
+
+```
+Task(
+  subagent_type: "stack-resolver",
+  description: "Resolve stack for project at CWD",
+  prompt: "resolve stack for project at CWD"
+)
+```
+
+b) Parse the first line of `stack-resolver` output:
+
+- **`[STACK: <lang>/<framework>-<major> | PACK: loaded]`** — extract the full `STACK CONTEXT` block from the response. Store it in memory as `STACK_CONTEXT_BLOCK` for use in Step 4 dispatch.
+- **`[STACK: <lang>/<framework>-<major> | PACK: none]`** — pack missing. Dispatch the `create-stack-pack` skill conversationally:
+
+  ```
+  Stack pack ausente para `<lang>/<framework>-<major>`. Disparando `create-stack-pack` para gerar agora; depois repito Stage 0.
+  ```
+
+  Once the pack is created, repeat Stage 0a.
+
+c) `STACK_CONTEXT_BLOCK` is now ready to inject as a prompt prefix into Step 4 dispatch (and any in-flow Task call this skill makes).
+
+If `stack-resolver` cannot determine the stack (no `## Project Identity` in CLAUDE.md, unparseable `Primary stack`), abort with a clear message:
+
+```
+Não consegui resolver a stack do projeto. Preencha a seção `## Project Identity` da CLAUDE.md com `Primary stack: <lang> <version> + <framework> <version>` e tente de novo.
+```
+
+### Step 2 — Ground in the codebase
+
+Read existing similar code via `Read`, `Glob`, `Grep`:
+- For backend: find an analogous endpoint/use case/service.
+- For frontend: find an analogous component/feature folder.
+- For database: find existing migration patterns + naming.
+
+State to the user in 2-3 lines what you found (anchoring the work in concrete files).
+
+### Step 3 — Generate minimal PLAN
+
+Write `docs/plans/PLAN_<slug>.md` with this slim structure:
+
+```markdown
+# PLAN — <feature title>
+
+- **Type**: quick-feature (fast-lane, bypassed discovery)
+- **Date**: <ISO>
+- **Estimated effort**: S (small, 1-3 tasks, ≤ 1 sprint)
+- **Bounded context**: <module/feature>
+- **Anchored in**: <list of existing files used as reference>
+- **Stack**: <lang>/<framework>-<major> (from Stage 0)
+
+## 1. User story (single, prose)
+
+As a <persona>, I want <capability>, so that <value>.
+
+## 2. Acceptance criteria (Given/When/Then)
+
+- Given <state>, When <action>, Then <result>.
+- (1-3 criteria — happy path + main edge case)
+
+## 3. Sprint 1 — Tasks
+
+### Task 1.1 — <verb + noun>
+- **Layer**: backend|frontend|migration|test
+- **Files touched** (expected): <list>
+- **Definition of Done** (goal-ready):
+  - `<command>` returns exit 0
+  - file `<path>` contains `<assertion>`
+  - test `<TestClass#method>` passes
+
+### Task 1.2 — ...
+
+### Task 1.3 — ... (optional)
+
+## 4. Out of scope (explicit)
+
+- <thing user might expect but isn't included>
+- (1-3 items to prevent scope creep)
+
+## 5. /goal block
+
+```
+/goal "PLAN_<slug>.md Sprint 1 is done when:
+1. <DoD task 1.1 verbatim>
+2. <DoD task 1.2 verbatim>
+3. ./mvnw verify returns exit 0
+4. npm test -- --watchAll=false returns exit 0
+5. gate-keeper returns GREEN on the new code
+"
+```
+```
+
+### Step 4 — Hand off to run-sprint
+
+Dispatch via Task tool, prefixing the prompt with the `STACK_CONTEXT_BLOCK` captured in Stage 0:
+
+```
+Task(
+  subagent_type: "sprint-runner",
+  description: "Execute Sprint 1 of PLAN_<slug>.md (quick-feature fast-lane)",
+  prompt: """<STACK_CONTEXT_BLOCK from Stage 0>
+
+caller: quick-feature
+plan_path: docs/plans/PLAN_<slug>.md
+sprint: 1
+
+This PLAN was generated via the quick-feature fast-lane skill — bypassed grill-me/to-prd/to-issues. Treat it as a normal PLAN for execution purposes. TDD is still mandatory (qa-engineer before developer). gate-keeper still validates senior+ thresholds at end-of-task.
+
+Stack already resolved upstream; reuse the STACK CONTEXT above when dispatching to backend-developer / frontend-developer / qa-engineer / gate-keeper instead of re-running stack-resolver."""
+)
+```
+
+### Step 5 — Done
+
+After `run-sprint` returns GREEN, suggest `brain-keeper` to register the feature:
+
+```
+Próximo passo: `registra no cérebro` (brain-keeper salva docs/brain/features/<slug>.md + daily note).
+```
+
+## 4. Inviolable rules
+
+1. **Sanity check in Step 1 is non-negotiable.** Bypass exists for clear cases; ambiguity = full pipeline.
+2. **Stage 0 stack pre-resolution is non-negotiable.** No dispatch to `run-sprint` without `STACK_CONTEXT_BLOCK` from `stack-resolver` (per ADR-026 Layer 1).
+3. **No skip of senior+ gate.** `gate-keeper` runs at end of every task in `run-sprint`, even via fast-lane.
+4. **TDD remains mandatory.** `sprint-runner` still spawns `qa-engineer` to write failing tests before the developer.
+5. **No ADR-level decisions inside quick-feature.** If during execution an architectural question surfaces, `sprint-runner` escalates to `tech-lead`.
+6. **PLAN is goal-ready.** DoD must reference concrete commands/files/tests verifiable by Claude Code's `/goal` evaluator.
+7. **Persist always.** Even fast-lane writes `PLAN_<slug>.md` — auditability is non-negotiable.
+
+## 5. Interface with other skills/agents
+
+- `stack-resolver` — invoked in Stage 0 to resolve project stack and load knowledge pack (ADR-026 Layer 1).
+- `create-stack-pack` — invoked from Stage 0 when pack is missing for the declared stack.
+- `grill-me` — alternative entry for ambiguous features. Use it when sanity check fails.
+- `analyst` — accepts quick-feature PLAN as valid seed (via `caller: quick-feature` signal in Task prompt; same exemption as `caller: sprint-runner|autonomous`).
+- `sprint-runner` — executes the generated PLAN normally; receives `STACK_CONTEXT_BLOCK` inline in its prompt to skip its own re-resolution.
+- `gate-keeper` — runs senior+ gate end-of-task regardless of how PLAN was produced.
+- `brain-keeper` — registers history post-sprint.
+
+## 6. Examples
+
+### Example A — adding a field
+
+User: `quick-feature: adicionar campo description em ProductRequest com validação NotBlank Size max 500`
+
+Skill output (after Stage 0 + Step 2 grounding):
+- Stage 0: `stack-resolver` returned `[STACK: java/spring-boot-4 | PACK: loaded]`. Loaded `.claude/stacks/java/spring-boot-4.md` (record DTO + Bean Validation + jakarta.validation).
+- Identified existing: `application/dto/ProductRequest.java` (current fields: name, price)
+- Identified existing: `web/controller/ProductController.java` (uses @Valid)
+- PLAN with 2 tasks:
+  - Task 1.1: add `@NotBlank @Size(max=500) String description` field + update tests
+  - Task 1.2: update OpenAPI spec + regenerate frontend types via `openapi-typescript`
+
+Step 4 dispatch:
+
+```
+Task(
+  subagent_type: "sprint-runner",
+  description: "Execute Sprint 1 of PLAN_product-description-field.md (quick-feature fast-lane)",
+  prompt: """[STACK: java/spring-boot-4 | PACK: loaded]
+
+STACK CONTEXT
+- Language: Java 25
+- Framework: Spring Boot 4.0.x
+- DTO pattern: record (immutable)
+- Validation: jakarta.validation (@Valid, @NotBlank, @Size)
+- (...pack body inlined...)
+
+caller: quick-feature
+plan_path: docs/plans/PLAN_product-description-field.md
+sprint: 1
+(...)"""
+)
+```
+
+### Example B — UI ajuste
+
+User: `feature pequena: adicionar dialog de confirmação antes de deletar pedido`
+
+Skill output:
+- Stage 0: `stack-resolver` returned `[STACK: typescript/angular-21 | PACK: loaded]`.
+- Identified existing: `features/orders/order-list.component.ts` (uses NgbModal already)
+- PLAN with 2 tasks:
+  - Task 1.1: extrair ConfirmDialogComponent reutilizável em `shared/components/` (3 arquivos separados conforme pack Angular 21)
+  - Task 1.2: integrar em `OrderListComponent.delete()` + teste Jest + a11y
+
+### Example C — caso que NÃO encaixa
+
+User: `quick-feature: refatorar o módulo de pagamento pra usar Strategy Pattern`
+
+Skill output:
+> Sanity check falhou (Q3: requer ADR sobre pattern). Use o fluxo completo: `grill me sobre refatorar pagamento` → produz DISCOVERY → ADR de pattern → PLAN normal. Esta skill é só para features pequenas sem decisão arquitetural.
+
+### Example D — pack ausente
+
+User: `quick-feature: adicionar endpoint /health customizado`
+
+Skill output (Stage 0):
+- `stack-resolver` returned `[STACK: python/fastapi-0.115 | PACK: none]`.
+- Disparando `create-stack-pack` para gerar `.claude/stacks/python/fastapi-0.md` (conversa de 5-8 perguntas).
+- Após pack criado, repito Stage 0a → `PACK: loaded` → segue para Step 2.

package/.claude/skills/run-sprint/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: run-sprint
+description: Use when an approved development plan exists (in docs/plans/PLAN_*.md) and the user asks to execute a specific sprint. Triggers on phrases like "run sprint 1", "execute sprint 2 of plan X", "implement the current sprint tasks", "let's code this sprint", "take PLAN_product_registration and run sprint 1". This skill does NOT create a plan — it CONSUMES a plan. To create a plan use analyst. This skill does NOT validate for PRD — it implements. For the final gate use prd-ready-check. Do NOT use to create a development plan (use analyst) nor to validate PRD-readiness (use prd-ready-check). PT triggers: 'roda a sprint 1', 'executa a sprint', 'implementa as tarefas da sprint', 'bora codar essa sprint'.
+tools: Read, Glob, Bash(node:*)
+model: sonnet
+---
+
+# run-sprint — Thin trigger (ADR-042)
+
+Capture intent and delegate to `sprint-runner` agent. All execution logic lives there.
+
+## Input
+
+- **Plan**: `docs/plans/PLAN_<NAME>.md` (mandatory).
+- **Sprint**: number or name (mandatory). Ask if missing.
+
+## Step 0 — Harness self-dev bypass (ADR-046)
+
+If `package.json` at repo root has `name: "@eltonssouza/development-utility-kit"` OR `bin/cli.js` exists at root:
+- Skip `stack-resolver`.
+- Pass `harness_self_dev: true` to the sprint-runner Task so it uses `duk lint` + smoke tests as the gate.
+
+Otherwise: sprint-runner handles stack resolution internally (Stage 0 of its flow).
+
+## Dispatch
+
+```
+Task(
+  subagent_type="sprint-runner",
+  description="execute sprint <N> of <PLAN>",
+  prompt="""
+Plan: <plan path>
+Sprint: <sprint number or name>
+Harness self-dev: <true | false>
+
+Execute the sprint per the sprint-runner contract.
+"""
+)
+```
+
+Return the sprint-runner report verbatim.

package/.claude/skills/scaffold/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: scaffold
+description: "Unified entry point for new project scaffolding. Triggers when user wants to create a new project skeleton — backend, frontend, or fullstack. Keyword triggers: 'scaffold the project', 'scaffold backend', 'scaffold frontend', 'scaffold backend and frontend', 'create fullstack skeleton', 'bootstrap fullstack', 'bootstrap backend', 'bootstrap frontend', 'monta o esqueleto', 'scaffolda o projeto', 'monta a estrutura', 'cria o esqueleto', 'inicializa o backend', 'inicializa o frontend', 'cria novo projeto', 'criar esqueleto do projeto', 'criar estrutura do projeto'. Reads `type:` from `## Project Identity` section in CLAUDE.md. DO NOT use for feature implementation after scaffold — use backend-developer / frontend-developer."
+tools: Read, Write, Edit, Glob, Grep, Bash(mvn:*), Bash(npm:*), Bash(npx:*), Bash(ng:*)
+model: haiku
+---
+
+# Scaffold — Unified Project Scaffolding Entry Point
+
+This skill is the single entry point for all project scaffold operations.
+It reads the project type from CLAUDE.md and dispatches to the `scaffold` agent.
+
+## When to trigger
+
+Use this skill at the **very first conversation** of a new project, before any Java or Angular code exists. Scenarios:
+
+- "scaffold the project" / "scaffolda o projeto"
+- "monta a estrutura" / "monta o esqueleto"
+- "create fullstack skeleton" / "cria o esqueleto" / "bootstrap fullstack"
+- "scaffold the backend" / "bootstrap backend" / "inicializa o backend"
+- "scaffold the frontend" / "bootstrap frontend" / "inicializa o frontend"
+- "create new project" / "cria novo projeto"
+- Any variant: "criar esqueleto do projeto", "criar estrutura do projeto", "monta o monorepo"
+
+## Prerequisites
+
+1. The project's `CLAUDE.md` must exist at the project root.
+2. The `## Project Identity` section must have `- **Project type**: \`backend\`` | `\`frontend\`` | `\`fullstack\``.
+3. The project folder must be under `C:\development\source\projects\<name>\`.
+4. No `backend/pom.xml`, `frontend/angular.json`, or `frontend/package.json` exists yet (idempotent guard is in the agent).
+
+If `Project type` is missing or unrecognized, the `scaffold` agent routes to `tech-lead` automatically.
+
+## Do NOT use for
+
+- Implementing features after scaffold is complete — use `backend-developer` / `frontend-developer`.
+- Migrating an existing project to a newer stack — use `migrator`.
+- Updating the harness template — use `update-template`.
+- Adopting the template in an existing project — use `active-project`.
+
+## Dispatch
+
+```
+Task(
+  subagent_type: "scaffold",
+  description: "Scaffold the project. Read ## Project Identity from CLAUDE.md, detect project type, run the appropriate pipeline (backend | frontend | fullstack).",
+  prompt: "<full user message>"
+)
+```
+
+The `scaffold` agent (`.claude/agents/scaffold.md`, model: haiku) handles:
+- Reading `## Project Identity` → parsing `Project type:` value.
+- Running the Spring Initializr pipeline (backend), Angular CLI pipeline (frontend), or both (fullstack).
+- Smoke builds and final report.
+
+## Handoff
+
+After dispatch, the `scaffold` agent handles execution autonomously. All decisions about Java packages, ports, optional dependencies are resolved by the agent (it may ask the user for missing values per its inviolable rules).
+
+See `.claude/agents/scaffold.md` for the complete execution contract, pipeline steps, and inviolable rules.

package/.claude/skills/stack-discovery/SKILL.md

@@ -0,0 +1,161 @@
+---
+name: stack-discovery
+description: "Conversational sabatina for NEW projects with empty Project Identity in CLAUDE.md. Walks user through 5-8 focused questions to declare language, framework, version, database, UI lib, domain. Each question comes with a recommended answer + 1-line rationale (same UX pattern as grill-me, but focused on stack rather than feature requirements). Persists results to ## Project Identity in CLAUDE.md. If the chosen stack has no matching pack in .claude/stacks/, dispatches create-stack-pack skill. Triggers: 'sabatina pra projeto novo', 'stack discovery', 'ajuda escolher stack', 'configura stack', 'duk new chat', auto-triggered after duk new <name> creates empty Project Identity. Do NOT use for feature discovery (use grill-me), to migrate stack of existing project (use migrator), or for code implementation. PT triggers: 'sabatina pra projeto novo', 'discovery da stack', 'configura stack do projeto', 'duk new chat'."
+tools: Read, Write, Edit, Glob, Grep
+model: sonnet
+---
+
+# Stack-discovery — conversational sabatina for new projects
+
+> Sonnet conversational skill. Walks the human through declaring the project's stack — language, framework, version, database, UI lib, domain — and persists the answers to `## Project Identity` in `CLAUDE.md`. UX mirrors `grill-me`: one focused question per turn, each with a recommended answer + 1-line rationale.
+
+---
+
+## 1. When you trigger
+
+- "sabatina pra projeto novo", "stack discovery", "ajuda escolher stack", "configura stack", "duk new chat".
+- Auto-triggered after `duk new <name>` scaffolds a project with empty `## Project Identity` placeholders (`<project-name>`, etc.).
+- Manual invocation when adopting a new project where the stack is not yet declared.
+
+## 2. When you do NOT trigger
+
+- Project already has a populated `## Project Identity` -> use `update-template` to refresh harness files.
+- Existing project changing stack (Java 21 -> 25, Angular 19 -> 21) -> use `migrator`.
+- Feature requirements discovery -> use `grill-me`.
+- Implementation -> use `run-sprint` / specialist agents.
+- Scaffold the project skeleton -> use `scaffold` skill (run AFTER this skill finishes).
+
+## 3. Prerequisites
+
+- `CLAUDE.md` exists at project root with the harness template's `## Project Identity` section.
+- An engaged human (this is conversational — never invoke from `sprint-runner` or CI).
+
+## 4. Flow
+
+### Step 1 — Frame
+
+Open with a 1-line intro: "Vou entrevistar sobre stack — 6-8 perguntas, uma por turno. Persisto tudo em CLAUDE.md no fim."
+
+### Step 2 — Sabatina (8 questions, one per turn)
+
+Each question follows the grill-me pattern: question + recommended answer + 1-line rationale + "Confirm?". Default by context (if user said "API backend" earlier, default Q2 to `java`).
+
+**Q1 — Project type**
+> Tipo de projeto: `backend` / `frontend` / `fullstack` / `mobile` / `library` / `cli`?
+> Recomendo: **fullstack** (se você vai ter API + UI integradas). Confirme?
+
+**Q2 — Language**
+> Linguagem principal: `java` / `typescript` / `python` / `go` / `rust` / `kotlin`?
+> Recomendo: **java** para backend corporativo (ecossistema maduro, equipe domina). Confirme?
+
+**Q3 — Framework**
+> Framework: `spring-boot` / `quarkus` / `micronaut` (Java) | `angular` / `react` / `vue` (TS) | `django` / `fastapi` (Python) | `gin` / `echo` (Go)?
+> Recomendo: **spring-boot** (defaults do harness, packs prontos). Confirme?
+
+**Q4 — Major version**
+> Versão major: para Spring Boot, `3` (Java 17/21, legado mantido) ou `4` (Java 25, novos)?
+> Recomendo: **4** para projeto novo (target da equipe, packs canônicos). Confirme?
+>
+> _Nota: stack-discovery PODE consultar Maven Central / npm registry pra confirmar a última GA. Fallback é o hardcoded em `scripts/latest-versions.json`._
+
+**Q5 — Database (if backend / fullstack)**
+> SGBD: `postgresql` / `mysql` / `mongodb` / `none`?
+> Recomendo: **postgresql** (default do harness — UUID, JSONB, transações ACID). Confirme?
+
+**Q6 — UI library (if frontend / fullstack / mobile)**
+> Lib de UI: `ng-bootstrap` / `material` / `primeng` (Angular) | `mui` / `chakra` / `tailwind` (React)?
+> Recomendo: **ng-bootstrap** (default do harness, a11y WCAG 2.1 AA). Confirme?
+
+**Q7 — Domain**
+> Domínio do produto: e-commerce / fintech / healthcare / SaaS interno / marketplace / outro?
+> Recomendo: marque o que mais aproxima — usado em prompts de geração e ADRs. Confirme?
+
+**Q8 — Team size**
+> Tamanho do time: solo / 2-3 devs / 4-10 devs / 10+?
+> Recomendo: **2-3 devs** (calibra Autonomy Matrix, ritmo de PR, gate rigor). Confirme?
+
+### Step 3 — Latest version detection (opcional, automático)
+
+Antes de fechar a sabatina, se `Q3 + Q4` apontam para uma stack com versão major declarada, consulte (silenciosamente) Maven Central / npm registry para confirmar a última GA daquela major. Se diferir do que o user respondeu, retorne 1 pergunta de confirmação: "Detectei que Spring Boot 4.0.2 é a última GA — usar essa versão na CLAUDE.md? Recomendo: sim."
+
+Fallback determinístico: `scripts/latest-versions.json` (hardcoded no harness).
+
+### Step 4 — Confirm
+
+Mostre o bloco `## Project Identity` proposto e peça OK final:
+
+```markdown
+## Project Identity
+
+- **Project name**: `meu-projeto`
+- **Project type**: `fullstack`
+- **Primary stack**: `Java 25 + Spring Boot 4.0.2 + Angular 21`
+- **Database**: `PostgreSQL 17 + Redis 7`
+- **Domain**: `e-commerce`
+- **Team size**: `2-3 devs`
+- **Additional rules**: _(vazio)_
+```
+
+### Step 5 — Persist (MANDATORY)
+
+Use `Edit` para substituir SOMENTE a seção `## Project Identity` em `CLAUDE.md`. Demais seções permanecem intactas (base do plugin). Validar via `Read` pós-Edit.
+
+### Step 6 — Pack check + handoff
+
+1. Resolva pack esperado: `.claude/stacks/<lang>/<framework>-<major>.md`.
+2. **Se pack existe** -> imprima sucesso + próximos passos (ver §Output).
+3. **Se pack ausente** -> dispatch `create-stack-pack` skill ANTES de finalizar:
+   > "Pack `.claude/stacks/java/spring-boot-5.md` não existe. Disparando `create-stack-pack` para gerar antes de continuar."
+   Depois que `create-stack-pack` retorna, feche com o output normal.
+
+## 5. Inviolable rules
+
+1. **Sabatina conversacional, opt-in.** Nunca rode em CI, `sprint-runner`, ou qualquer fluxo autônomo.
+2. **Uma pergunta por turno, sempre com recomendação.** Nunca dump de lista, nunca pergunta aberta sem default.
+3. **Persistência obrigatória.** Sessão não fecha sem `## Project Identity` preenchida em `CLAUDE.md`.
+4. **Edit cirúrgico.** Só toca em `## Project Identity` — preserva todo o resto do template (override do plugin).
+5. **Pack ausente bloqueia handoff.** Dispatch `create-stack-pack` antes do output final.
+6. **Nunca decide stack pelo user.** Recomenda, mas o user confirma a cada Q.
+7. **No implementation.** Esta skill só descobre + persiste — código vem do `scaffold` skill depois.
+
+## 6. Output
+
+Bloco final em chat:
+
+```
+✓ Project Identity persistida em CLAUDE.md
+✓ Pack resolvido: .claude/stacks/java/spring-boot-4.md (loaded)
+
+Próximos passos sugeridos:
+  1. Rode 'scaffolda o projeto' para gerar a estrutura inicial (backend + frontend).
+  2. Quando tiver primeira feature em mente, rode 'grill me sobre <feature>' pra discovery.
+  3. Depois, 'analyst' gera PLAN -> 'sprint-runner' executa.
+```
+
+Se pack faltava e foi gerado:
+
+```
+✓ Project Identity persistida em CLAUDE.md
+✓ Pack criado via create-stack-pack: .claude/local/stacks/java/spring-boot-5.md
+   Considere abrir PR pro harness repo (development-utility-kit) pra reusar.
+
+Próximos passos:
+  1. Rode 'scaffolda o projeto' para gerar a estrutura inicial.
+```
+
+## 7. Interface with other skills/agents
+
+- `scaffold` — handoff natural após esta skill (gera esqueleto baseado em `## Project Identity`).
+- `create-stack-pack` — disparado SE pack ausente para a stack escolhida.
+- `stack-resolver` — agente Haiku que valida o pack pós-persistência (usado pelas skills downstream).
+- `grill-me` — fase seguinte, quando user tem primeira feature em mente.
+- `update-template` — não invocar daqui; é caminho separado para sincronizar harness em projeto já adotado.
+- `migrator` — não confundir: este é para projeto NOVO; migrator é para mudar stack de projeto existente.
+
+## 8. References
+
+- ADR-026 (Generic agents + stack packs — fundação)
+- ADR-028 (duk workflow — esta skill é o passo "new chat" do fluxo)
+- ADR-029 (Pack canonical format — o que `create-stack-pack` deve gerar)
+- `.claude/skills/grill-me/SKILL.md` (padrão UX de sabatina reusado aqui)
+- `scripts/latest-versions.json` (fallback de versões hardcoded)

package/.claude/skills/test-coverage-auditor/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: test-coverage-auditor
+description: Use to AUDIT the project's automated test coverage and flag TECHNICAL DEBT from manual verification. Triggers on "audit the tests", "is there test debt?", "is coverage ok?", "what depends on manual testing here?", "do a coverage audit", "list what has no test", "look for test debt". Also called automatically by `run-sprint` (Stage 5) and is a mandatory prerequisite of `prd-ready-check`. Scans backend code (controllers, services, domain) and frontend code (components, HTTP services, guards), checks whether matching automated tests exist (JUnit/Mockito/Testcontainers or Jest/Testing Library/Playwright), reads recent dailies and feature notes looking for "tested manually", "checked in the browser", "deployed and tested", and emits a debt report. Updates `docs/brain/architecture/tech-debt.md` and creates notes in `docs/brain/bugs/` for critical debt items. Does NOT implement tests — only flags them. To write the tests, use `backend-developer` / `frontend-developer` / `qa-engineer`. Do NOT use to write tests (use those specialists) nor to run the regression suite (use auto-test-guard). PT triggers: 'audita os testes', 'tem débito de teste?', 'cobertura tá ok?', 'o que depende de teste manual aqui?', 'faz auditoria de cobertura', 'lista o que não tem teste', 'procura débito de teste'.
+tools: Read, Glob, Grep, Bash(git log:*), Bash(find:*)
+model: sonnet
+---
+
+# Test Coverage Auditor — Test technical debt detector
+
+Skill that invokes the `test-coverage-auditor` agent. Always respond in American English.
+
+---
+
+## When to trigger
+
+**Explicit**:
+- "audit the tests", "is there test debt here?", "is coverage ok?"
+- "what depends on manual testing?", "look for test debt", "list what has no test"
+- "do a coverage audit"
+
+**Automatic**:
+- `run-sprint` Stage 5 — mandatory gate between integration (Stage 4) and PRD-ready (Stage 6).
+- `prd-ready-check` — production gate requires an up-to-date report with no open P0/P1.
+
+---
+
+## Prerequisites
+
+- Project has `backend/` and/or `frontend/` directories with source code.
+- `CLAUDE.md` exists at the project root with `## Project Identity` declaring the project type.
+
+---
+
+## Do NOT use for
+
+- Writing tests — use `qa-engineer` / `backend-developer` / `frontend-developer`.
+- Running the regression suite — use `gate-keeper` (auto-test-guard skill).
+- Performance or security audits — use `security-engineer` for those.
+
+---
+
+## Execution
+
+Standalone skill (Pattern 3 per ADR-037). The calling session scans the repo inline using `Glob`, `Grep`, `Bash(git log:*)`, `Bash(find:*)` from the frontmatter — no Task dispatch.
+
+### Sequence
+
+1. **Read `## Project Identity`** from `CLAUDE.md` (stack, project type — backend / fullstack / mobile / ...).
+2. **Backend scan** — enumerate `controller`, `service`, `repository`, domain entities (paths + naming from the relevant stack pack `## Code patterns`). For each source file, check for a matching test file (e.g. `FooController.java` → `FooControllerTest.java`).
+3. **Frontend scan** (if fullstack) — enumerate `component`, `service`, `guard`, `pipe`. Match against `*.spec.ts` / `*.test.tsx` / equivalent.
+4. **Recent activity scan** — `git log --since="30 days ago"` + read `docs/brain/daily/` + `docs/brain/features/` for phrases like "tested manually", "checked in the browser", "deployed and tested". Each is a candidate manual-verification debt.
+5. **Severity classification**:
+   - **P0** — production code path, no automated test AND no manual evidence (silent gap).
+   - **P1** — production code path, no automated test BUT manual verification documented.
+   - **P2** — non-critical path (config, log helper) with no test.
+   - **P3** — test exists but is shallow (asserts truthiness only).
+6. **Write debt report** — append to `docs/brain/architecture/tech-debt.md` (never overwrite). Create individual notes under `docs/brain/bugs/` only for P0 items.
+
+### Output format
+
+```
+Test Coverage Audit — <date> — <project>
+
+Backend
+  Classes scanned: 47
+  Without test:    8
+  Without test + no manual evidence (P0): 3
+
+Frontend
+  Components scanned: 23
+  Without test:       5
+  Without test + no manual evidence (P0): 1
+
+Open P0:
+  - src/main/java/.../ProductController.java — last touched 2026-05-22, no test, no manual log
+  - src/main/java/.../PriceCalculator.java   — last touched 2026-05-28, no test, no manual log
+  - src/app/checkout/checkout.component.ts   — last touched 2026-05-15, no test, no manual log
+
+Open P1:
+  - src/main/java/.../OrderService.java — no test, manual log on 2026-05-20 ("tested in staging")
+
+PRD-ready gate verdict: NO-GO (4 open P0/P1)
+
+Routing: qa-engineer to write the missing tests; backend-developer or frontend-developer if the source needs testability refactors first.
+```
+
+Never write the missing tests yourself — flag and route only.