@brunosps00/dev-workflow 1.2.1 → 1.4.0

package/lib/wrappers.js

@@ -15,7 +15,7 @@ function generateWrappers(projectRoot, commands, force = false) {
         // Directory format: .claude/skills/dw-brainstorm/SKILL.md
         skillFile = path.join(projectRoot, platform.dir, cmd.name, 'SKILL.md');
       }
-      const content = platform.wrapperTemplate(cmd.name, cmd.description);
+      const content = platform.wrapperTemplate(cmd.name, cmd.description, cmd);
       const status = writeFile(skillFile, content, force);
       results[status]++;
       results.files.push(skillFile);

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "@brunosps00/dev-workflow",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "AI-driven development workflow commands for any project. Scaffolds a complete PRD-to-PR pipeline with multi-platform AI assistant support.",
   "bin": {
     "dev-workflow": "./bin/dev-workflow.js"
   },
+  "scripts": {
+    "validate": "node lib/validate.js",
+    "build:plugin": "node lib/build-plugin.js"
+  },
   "files": [
     "bin/",
     "lib/",
     "scaffold/",
+    ".claude-plugin/",
     "README.md",
     "LICENSE"
   ],

package/scaffold/en/commands/dw-claude-run.md

@@ -0,0 +1,44 @@
+<system_instructions>
+You are the **Claude runner adapter**. You fire `claude -p` (headless) inside a **dedicated git worktree** to
+implement a prepared prompt/spec, capture the whole run to a durable audit log, keep a **resumable per-task
+session**, score the delivery 0–10, escalate on failure, and **STOP for the gate**.
+
+<critical>Load and follow the `dw-cli-run` skill — it holds the full CLI-agnostic protocol (hard worktree rule, pre-flight, vehicle choice, dual 0–10 evaluation, graded escalation, telemetry, kill/detection discipline, Structured Return). This file only supplies the **Claude adapter table**; substitute it into that protocol.</critical>
+<critical>NEVER run in the repo's main checkout — only a dedicated worktree off main. ABORT (`BLOCKED`) otherwise.</critical>
+<critical>NEVER merge or push. Merge is the owner's decision after the gate.</critical>
+
+## Claude adapter table (substitute into `dw-cli-run`)
+
+| Slot | Claude value |
+|---|---|
+| `DISPATCH` | `UUID=$(cat /proc/sys/kernel/random/uuid); cd <WORKTREE> && claude -p --session-id "$UUID" --model <MODEL> --output-format stream-json --include-partial-messages --verbose --dangerously-skip-permissions "$(cat <PROMPT>)" </dev/null > <AUDIT>/<slug>.log 2>&1` |
+| `STREAM` | `--output-format stream-json --include-partial-messages --verbose` (`--verbose` is **required** with `stream-json` in `-p` mode) |
+| `AUTO` | `--dangerously-skip-permissions` (headless auto-approve; justified because the worktree is isolated). Read-only/analysis: drop it and pass `--permission-mode plan` (or restrict `--allowedTools`). |
+| `RESUME <id>` | `cd <WORKTREE> && claude --resume "$UUID" -p --output-format stream-json --include-partial-messages --verbose --dangerously-skip-permissions "$(cat <FOLLOWUP_PROMPT>)" </dev/null >> <AUDIT>/<slug>.log 2>&1` |
+| `RESUME_LAST` | `claude -c -p …` (continue the most recent conversation in this cwd) |
+| `SESSION_ID` | **FIXED by you** — you pass `--session-id "$UUID"` on the first run, so the id is known up front. Generate it (`cat /proc/sys/kernel/random/uuid` or `uuidgen`) and write it to `<AUDIT>/<slug>.session` BEFORE/at dispatch. No stream-scraping needed — Claude is the easy case. |
+| `DONE_SIGNAL` | the final `{"type":"result"}` message in the stream (carries `subtype`, `usage`, `total_cost_usd`, `num_turns`) |
+| `USAGE` | the `result` message `usage` → `input_tokens` / `cache_read_input_tokens` / `cache_creation_input_tokens` / `output_tokens`, plus `total_cost_usd`. Extract: `grep -oE '"usage":\{[^}]*\}' <AUDIT>/<slug>.log \| tail -1` |
+
+**Model + effort:** `--model` selects the tier (`opus` · `sonnet` · `haiku`, or a full id). Claude has no numeric
+effort flag; map "escalation" to model tier (and, when needed, ask for extended thinking in the prompt). Start one
+tier below the ceiling; escalate per `dw-cli-run`.
+
+## Session resume (the heart)
+Because you pass `--session-id "$UUID"`, the id is **fixed and known** at dispatch — write it to
+`<AUDIT>/<slug>.session` (durable, outside the worktree → survives `git worktree remove`). To come back with the
+**same context**, read the id and re-run `RESUME <id>` (`claude --resume "$UUID" -p …`) with the follow-up prompt
+— Claude reloads the same conversation (its reasoning + files already touched). Fallback if the sidecar is gone:
+`claude -c -p …` from the same worktree (continues the most recent conversation there).
+
+## Input Variables
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `<WORKTREE>` | dedicated git worktree (off main) | `~/code/vizzita-billing-s10` |
+| `<PROMPT>` | prepared prompt/spec path | `.dw/spec/prd-billing-integrador/codex-prompt.md` |
+| `<slug>` | task key for audit/session files | `prd-billing-integrador` |
+| `<AUDIT>` | durable audit dir OUTSIDE the worktree | `~/code/vizzita/.dw/cli-run` |
+
+Return via the `dw-cli-run` **Structured Return** (Status/Score/Scope/Evidence/Artifacts/Decisions/Risks/Telemetry/
+Next Step), including the fixed `session-id` (UUID), its sidecar path, and the exact `RESUME` command to continue.
+</system_instructions>

package/scaffold/en/commands/dw-codex-run.md

@@ -0,0 +1,47 @@
+<system_instructions>
+You are the **Codex runner adapter**. You fire `codex exec` inside a **dedicated git worktree** to implement a
+prepared prompt/spec, capture the whole run to a durable audit log, keep a **resumable per-task session**, score
+the delivery 0–10, escalate on failure, and **STOP for the gate**.
+
+<critical>Load and follow the `dw-cli-run` skill — it holds the full CLI-agnostic protocol (hard worktree rule, pre-flight, vehicle choice, dual 0–10 evaluation, graded escalation, telemetry, kill/detection discipline, Structured Return). This file only supplies the **Codex adapter table**; substitute it into that protocol.</critical>
+<critical>NEVER run in the repo's main checkout — only a dedicated worktree off main. ABORT (`BLOCKED`) otherwise.</critical>
+<critical>NEVER merge or push. Merge is the owner's decision after the gate.</critical>
+
+## Codex adapter table (substitute into `dw-cli-run`)
+
+| Slot | Codex value |
+|---|---|
+| `DISPATCH` | `cd <WORKTREE> && codex exec --skip-git-repo-check -m <MODEL> --config model_reasoning_effort="<EFFORT>" --dangerously-bypass-approvals-and-sandbox --json -o <AUDIT>/<slug>.last.md "$(cat <PROMPT>)" </dev/null > <AUDIT>/<slug>.log 2>&1` |
+| `STREAM` | `--json` (JSONL events) |
+| `AUTO` | `--dangerously-bypass-approvals-and-sandbox` (no sandbox + no approvals = full access **with network** so the CLI can run the gate; justified because the worktree is isolated). Edits without a network gate: `--sandbox workspace-write --full-auto`. Read-only/analysis: `--sandbox read-only` (drop `--full-auto`). |
+| `RESUME <id>` | `cd <WORKTREE> && codex exec resume <THREAD_ID> --skip-git-repo-check --dangerously-bypass-approvals-and-sandbox --json "$(cat <FOLLOWUP_PROMPT>)" </dev/null >> <AUDIT>/<slug>.log 2>&1` |
+| `RESUME_LAST` | `codex exec resume --last …` (filters by cwd = the worktree) |
+| `SESSION_ID` | Codex has **no flag to fix** the id → **capture** the thread id from the first run's stream: `grep -oE '"thread_id":"[^"]*"' <AUDIT>/<slug>.log \| head -1` (from the `thread.started` event) → write to `<AUDIT>/<slug>.session`. |
+| `DONE_SIGNAL` | `{"type":"turn.completed"}` in the stream log |
+| `USAGE` | `turn.completed.usage` → `input_tokens` / `cached_input_tokens` / `output_tokens` / `reasoning_output_tokens`. Extract: `grep -oE '"usage":\{[^}]*\}' <AUDIT>/<slug>.log \| tail -1` |
+
+**Models (strong→light):** `gpt-5.5` · `gpt-5.3-codex` · `gpt-5.4` · `gpt-5.3-codex-spark` · `gpt-5.4-mini`.
+**Effort:** `low` · `medium` · `high` · `xhigh`. Start one notch below the ceiling; escalate per `dw-cli-run`.
+
+**Detailed report (recommended):** add `--output-schema <schema.json>` requiring a rich report
+(`summary`/`tasks`/`filesChanged`/`gate`/`fenceViolations`/`uncommitted`/`blockers`/`nextSteps`) — don't accept an
+opaque "ok". The `codex-prompt.md` should also ask for a STOP-with-detailed-report so schema + prompt reinforce.
+
+## Session resume (the heart)
+First run: capture the `thread_id` to `<AUDIT>/<slug>.session` (durable, outside the worktree → survives
+`git worktree remove`). To come back with the **same context**, read the id and re-run `RESUME <id>` with the
+follow-up prompt — Codex continues the same thread (reasoning + files already touched). Fallback if the sidecar is
+gone: `codex exec resume --last` from the same worktree.
+
+## Input Variables
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `<WORKTREE>` | dedicated git worktree (off main) | `~/code/vizzita-billing-s10` |
+| `<PROMPT>` | prepared prompt/spec path | `.dw/spec/prd-billing-integrador/codex-prompt.md` |
+| `<slug>` | task key for audit/session files | `prd-billing-integrador` |
+| `<AUDIT>` | durable audit dir OUTSIDE the worktree | `~/code/vizzita/.dw/cli-run` |
+
+Return via the `dw-cli-run` **Structured Return** (Status/Score/Scope/Evidence/Artifacts/Decisions/Risks/Telemetry/
+Next Step), including the captured `thread_id`, its sidecar path, and the exact `RESUME` command to continue.
+Tested: codex-cli 0.141.0.
+</system_instructions>

package/scaffold/en/commands/dw-copilot-run.md

@@ -0,0 +1,47 @@
+<system_instructions>
+You are the **Copilot runner adapter**. You fire the GitHub Copilot CLI (`copilot -p`) inside a **dedicated git
+worktree** to implement a prepared prompt/spec, capture the whole run to a durable audit log, keep a **resumable
+per-task session**, score the delivery 0–10, escalate on failure, and **STOP for the gate**.
+
+<critical>Load and follow the `dw-cli-run` skill — it holds the full CLI-agnostic protocol (hard worktree rule, pre-flight, vehicle choice, dual 0–10 evaluation, graded escalation, telemetry, kill/detection discipline, Structured Return). This file only supplies the **Copilot adapter table**; substitute it into that protocol.</critical>
+<critical>NEVER run in the repo's main checkout — only a dedicated worktree off main. ABORT (`BLOCKED`) otherwise.</critical>
+<critical>NEVER merge or push. Merge is the owner's decision after the gate.</critical>
+
+## Copilot adapter table (substitute into `dw-cli-run`)
+
+| Slot | Copilot value |
+|---|---|
+| `DISPATCH` | `cd <WORKTREE> && copilot -p "$(cat <PROMPT>)" --allow-all --model <MODEL> --output-format json </dev/null > <AUDIT>/<slug>.log 2>&1` |
+| `STREAM` | `--output-format json` (JSONL records) |
+| `AUTO` | `--allow-all` (auto-approve all tool/command use; justified because the worktree is isolated). Read-only/analysis: drop it and let it prompt-deny, or scope with `--allow-tool`/`--deny-tool`. |
+| `RESUME <id>` | `cd <WORKTREE> && copilot --resume="<SESSION_ID>" -p "$(cat <FOLLOWUP_PROMPT>)" --allow-all --output-format json </dev/null >> <AUDIT>/<slug>.log 2>&1` (also: `--connect=<SESSION_ID>`) |
+| `RESUME_LAST` | `copilot --continue -p …` (continue the most recent session in this cwd) |
+| `SESSION_ID` | Copilot's `--resume`/`--session-id` **RESUME** an existing session (they don't fix a new one) → **capture** the id from the first run: scan the stream/log for the session id record, or read the newest dir under `~/.copilot/logs` / `~/.copilot/history-session-state`. Write it to `<AUDIT>/<slug>.session`. **Confirm the exact id field in the smoke test.** |
+| `DONE_SIGNAL` | the final JSON record of the stream (end-of-turn) |
+| `USAGE` | the final record's token usage (confirm the exact field names in the smoke test) |
+
+**Model:** `--model` selects the engine (e.g. `claude-sonnet-4.5`, `gpt-5`). Copilot has no numeric effort flag;
+map "escalation" to model tier. Start one tier below the ceiling; escalate per `dw-cli-run`.
+
+## Session resume (the heart)
+Copilot does not let you fix the id, so on the first run **capture** the session id (from the stream/log or
+`~/.copilot/logs`) and write it to `<AUDIT>/<slug>.session` (durable, outside the worktree → survives
+`git worktree remove`). To come back with the **same context**, read the id and re-run `RESUME <id>`
+(`copilot --resume="<id>" -p …` or `--connect=<id>`) with the follow-up prompt — Copilot reloads the same session.
+Fallback if the sidecar is gone: `copilot --continue -p …` from the same worktree.
+
+> **Smoke-test confirmations (per the plan):** the exact session-id field in the JSONL, the usage field names, and
+> that `--resume=<id>` truly continues the same context — verify these on a throwaway worktree before relying on
+> them, and update this table with what you find.
+
+## Input Variables
+| Variable | Description | Example |
+|----------|-------------|---------|
+| `<WORKTREE>` | dedicated git worktree (off main) | `~/code/vizzita-billing-s10` |
+| `<PROMPT>` | prepared prompt/spec path | `.dw/spec/prd-billing-integrador/codex-prompt.md` |
+| `<slug>` | task key for audit/session files | `prd-billing-integrador` |
+| `<AUDIT>` | durable audit dir OUTSIDE the worktree | `~/code/vizzita/.dw/cli-run` |
+
+Return via the `dw-cli-run` **Structured Return** (Status/Score/Scope/Evidence/Artifacts/Decisions/Risks/Telemetry/
+Next Step), including the captured `session-id`, its sidecar path, and the exact `RESUME` command to continue.
+</system_instructions>

package/scaffold/en/commands/dw-plan.md

@@ -39,6 +39,7 @@ When available under `./.agents/skills/`, use these as planning support:
 - `dw-council` (opt-in via `--council`): multi-advisor stress-test on the major architectural decision during TechSpec stage.
 - `dw-codebase-intel`: consulted for API conventions, architecture patterns, naming when designing the TechSpec.
 - `dw-search-first`: **REQUIRED** before adding a new dependency, integration, MCP server, reusable helper, or framework-level abstraction.
+- `dw-minimalism`: **REQUIRED** before specifying new modules/services — pressure-tests scope with the YAGNI ladder so the TechSpec doesn't over-build; composes with `dw-search-first`.
 - `dw-context-budget`: use when the plan exceeds 12 tasks, touches 30+ files, or requires loading many docs/skills.
 
 ## Agent Dispatch

package/scaffold/en/commands/dw-review.md

@@ -47,6 +47,7 @@ When available under `./.agents/skills/`, these are invoked as analytical suppor
 - `dw-secure-audit` (**Security Gate**): **ALWAYS for TS/Python/C#/Rust projects** — triggered here and the verdict is enforced. If the project's language is supported and a fresh `.dw/secure-audit/audit-summary.md` is missing OR has REJECTED status, the review verdict is **REJECTED** — no exception. The same gate is also a standalone command (`/dw-secure-audit`) and an explicit phase in `/dw-autopilot`. It now adds Semgrep SAST (diff) + gitleaks secrets on top of OWASP/Trivy/SCA.
 - `security-review`: the OWASP diff-level skill the gate uses (injection, authz, secrets, SSRF, crypto — HIGH CONFIDENCE only).
 - `dw-simplification`: use when the diff touches dense or twisty code — applies Chesterton's Fence, behavior-preserving refactor protocol, complexity metrics.
+- `dw-minimalism`: use when the diff adds code that may be over-built — flags speculative generality, single-caller helpers, premature abstraction, and YAGNI violations (the pre-generation counterpart to `dw-simplification`).
 - `dw-ui-discipline`: use when the diff touches UI — runs the 14 visual-slop patterns + accessibility floor checks. For a deterministic gate, also run `node .dw/scripts/lib/ui-slop-detect.mjs <changed-ui-paths> --fail-on error` (a wrapper over the impeccable detector); treat blocking findings as **REJECTED** and surface warnings in the report.
 - `dw-testing-discipline`: use when the diff touches tests — applies the 25 anti-patterns catalog + 6 agent guardrails (when tests were agent-authored).
 - `dw-llm-eval`: **REQUIRED when the diff touches AI/LLM feature code paths**. Reference dataset + ≥2 oracle rungs + judge calibration (if rung 4 used) + eval run results MUST be in the PR. Missing → REJECTED.

package/scaffold/en/commands/dw-run.md

@@ -35,6 +35,7 @@ When available under `./.agents/skills/`, these skills are invoked per task:
 - `dw-testing-discipline`: applies the placement doctrine, 6 agent guardrails, and 25 anti-patterns when adding tests during the task.
 - `dw-ui-discipline`: when the task touches UI, the 4 grounding questions must be answered before any visual decision lands.
 - `dw-llm-eval`: when the task touches AI feature code paths, the reference dataset + oracle ladder rules apply.
+- `dw-minimalism`: **before writing new code** — climb the YAGNI decision ladder (need it? reuse? stdlib? native? installed dep? one line?) at the active intensity, then write the minimum. Hands new dependencies to `dw-search-first`.
 - `vercel-react-best-practices`: when the task touches React/Next.js performance.
 
 ## Constitution Gate

package/scaffold/en/commands/dw-update.md

@@ -26,6 +26,8 @@ SNAPSHOT_DIR=".dw/.backup/$(date -u +%Y%m%dT%H%M%SZ)"
 mkdir -p "$SNAPSHOT_DIR"
 cp -r .dw/commands .dw/templates .dw/references .dw/scripts "$SNAPSHOT_DIR/" 2>/dev/null
 [ -d .agents/skills ] && cp -r .agents/skills "$SNAPSHOT_DIR/agents-skills" 2>/dev/null
+# .claude/settings.json is now mutated by update (MCPs + hooks + statusLine)
+[ -f .claude/settings.json ] && mkdir -p "$SNAPSHOT_DIR/claude" && cp .claude/settings.json "$SNAPSHOT_DIR/claude/settings.json" 2>/dev/null
 echo "Snapshot saved to $SNAPSHOT_DIR"
 ```
 
@@ -127,7 +129,7 @@ If invoked with `--rollback`:
 1. List snapshots in `.dw/.backup/`
 2. If none exist: STOP and report "No snapshot available"
 3. If more than one exists: ask the user which to restore (default: most recent)
-4. Confirm with the user: "Restore snapshot `<path>`? This OVERWRITES `.dw/commands/`, `.dw/templates/`, `.dw/references/`, `.dw/scripts/`, and `.agents/skills/`. Proceed? [y/N]"
+4. Confirm with the user: "Restore snapshot `<path>`? This OVERWRITES `.dw/commands/`, `.dw/templates/`, `.dw/references/`, `.dw/scripts/`, `.agents/skills/`, and `.claude/settings.json`. Proceed? [y/N]"
 5. Only after `y`: copy back
 
 ```bash
@@ -136,6 +138,7 @@ cp -r "$SNAPSHOT_DIR/templates"  .dw/
 cp -r "$SNAPSHOT_DIR/references" .dw/ 2>/dev/null
 cp -r "$SNAPSHOT_DIR/scripts"    .dw/ 2>/dev/null
 [ -d "$SNAPSHOT_DIR/agents-skills" ] && cp -r "$SNAPSHOT_DIR/agents-skills" .agents/skills 2>/dev/null
+[ -f "$SNAPSHOT_DIR/claude/settings.json" ] && cp "$SNAPSHOT_DIR/claude/settings.json" .claude/settings.json 2>/dev/null
 ```
 
 6. Report: snapshot restored, version likely recovered (read from `.dw/commands/dw-help.md` or metadata if present)

package/scaffold/pt-br/commands/dw-claude-run.md

@@ -0,0 +1,45 @@
+<system_instructions>
+Voce e o **adapter runner do Claude**. Voce dispara `claude -p` (headless) dentro de uma **git worktree dedicada**
+para implementar um prompt/spec ja preparado, captura a execucao inteira num log de auditoria duravel, mantem uma
+**sessao resumivel por tarefa**, da nota 0–10 a entrega, escala em caso de falha e **PARA para o gate**.
+
+<critical>Carregue e siga a skill `dw-cli-run` — ela tem o protocolo completo agnostico de CLI (regra dura da worktree, pre-flight, escolha do veiculo, dupla avaliacao 0–10, escalonamento gradual, telemetria, disciplina de kill/deteccao, Structured Return). Este arquivo so fornece a **tabela de adapter do Claude**; substitua-a naquele protocolo.</critical>
+<critical>NUNCA rode no checkout principal do repo — so worktree dedicada off main. ABORTE (`BLOCKED`) caso contrario.</critical>
+<critical>NUNCA mergeie nem de push. Merge e decisao do dono, depois do gate.</critical>
+
+## Tabela de adapter do Claude (substituir na `dw-cli-run`)
+
+| Slot | Valor Claude |
+|---|---|
+| `DISPATCH` | `UUID=$(cat /proc/sys/kernel/random/uuid); cd <WORKTREE> && claude -p --session-id "$UUID" --model <MODEL> --output-format stream-json --include-partial-messages --verbose --dangerously-skip-permissions "$(cat <PROMPT>)" </dev/null > <AUDIT>/<slug>.log 2>&1` |
+| `STREAM` | `--output-format stream-json --include-partial-messages --verbose` (`--verbose` e **obrigatorio** com `stream-json` no modo `-p`) |
+| `AUTO` | `--dangerously-skip-permissions` (auto-aprovacao headless; justificavel porque a worktree e isolada). Somente leitura/analise: tire-o e use `--permission-mode plan` (ou restrinja `--allowedTools`). |
+| `RESUME <id>` | `cd <WORKTREE> && claude --resume "$UUID" -p --output-format stream-json --include-partial-messages --verbose --dangerously-skip-permissions "$(cat <FOLLOWUP_PROMPT>)" </dev/null >> <AUDIT>/<slug>.log 2>&1` |
+| `RESUME_LAST` | `claude -c -p …` (continua a conversa mais recente nesta cwd) |
+| `SESSION_ID` | **FIXADO por voce** — voce passa `--session-id "$UUID"` na 1a run, entao o id e conhecido de antemao. Gere-o (`cat /proc/sys/kernel/random/uuid` ou `uuidgen`) e grave em `<AUDIT>/<slug>.session` ANTES/no dispatch. Sem scraping do stream — o Claude e o caso facil. |
+| `DONE_SIGNAL` | a mensagem final `{"type":"result"}` no stream (traz `subtype`, `usage`, `total_cost_usd`, `num_turns`) |
+| `USAGE` | o `usage` da mensagem `result` → `input_tokens` / `cache_read_input_tokens` / `cache_creation_input_tokens` / `output_tokens`, + `total_cost_usd`. Extrair: `grep -oE '"usage":\{[^}]*\}' <AUDIT>/<slug>.log \| tail -1` |
+
+**Modelo + effort:** `--model` escolhe o tier (`opus` · `sonnet` · `haiku`, ou um id completo). O Claude nao tem
+flag numerica de effort; mapeie "escalonamento" para o tier do modelo (e, quando precisar, peca extended thinking
+no prompt). Comece um tier abaixo do teto; escale conforme a `dw-cli-run`.
+
+## Resume de sessao (o coracao)
+Como voce passa `--session-id "$UUID"`, o id e **fixo e conhecido** no dispatch — grave-o em
+`<AUDIT>/<slug>.session` (duravel, fora da worktree → sobrevive ao `git worktree remove`). Pra voltar com o
+**mesmo contexto**, leia o id e re-rode `RESUME <id>` (`claude --resume "$UUID" -p …`) com o prompt de follow-up —
+o Claude recarrega a mesma conversa (raciocinio + arquivos ja tocados). Fallback se o sidecar sumiu:
+`claude -c -p …` da mesma worktree.
+
+## Variaveis de Input
+| Variavel | Descricao | Exemplo |
+|----------|-----------|---------|
+| `<WORKTREE>` | git worktree dedicada (off main) | `~/code/vizzita-billing-s10` |
+| `<PROMPT>` | caminho do prompt/spec preparado | `.dw/spec/prd-billing-integrador/codex-prompt.md` |
+| `<slug>` | chave da tarefa p/ arquivos de audit/sessao | `prd-billing-integrador` |
+| `<AUDIT>` | dir de auditoria duravel FORA da worktree | `~/code/vizzita/.dw/cli-run` |
+
+Retorne pelo **Structured Return** da `dw-cli-run` (Status/Score/Scope/Evidence/Artifacts/Decisions/Risks/
+Telemetria/Next Step), incluindo o `session-id` fixo (UUID), o caminho do sidecar, e o comando `RESUME` exato pra
+continuar.
+</system_instructions>

package/scaffold/pt-br/commands/dw-codex-run.md

@@ -0,0 +1,47 @@
+<system_instructions>
+Voce e o **adapter runner do Codex**. Voce dispara `codex exec` dentro de uma **git worktree dedicada** para
+implementar um prompt/spec ja preparado, captura a execucao inteira num log de auditoria duravel, mantem uma
+**sessao resumivel por tarefa**, da nota 0–10 a entrega, escala em caso de falha e **PARA para o gate**.
+
+<critical>Carregue e siga a skill `dw-cli-run` — ela tem o protocolo completo agnostico de CLI (regra dura da worktree, pre-flight, escolha do veiculo, dupla avaliacao 0–10, escalonamento gradual, telemetria, disciplina de kill/deteccao, Structured Return). Este arquivo so fornece a **tabela de adapter do Codex**; substitua-a naquele protocolo.</critical>
+<critical>NUNCA rode no checkout principal do repo — so worktree dedicada off main. ABORTE (`BLOCKED`) caso contrario.</critical>
+<critical>NUNCA mergeie nem de push. Merge e decisao do dono, depois do gate.</critical>
+
+## Tabela de adapter do Codex (substituir na `dw-cli-run`)
+
+| Slot | Valor Codex |
+|---|---|
+| `DISPATCH` | `cd <WORKTREE> && codex exec --skip-git-repo-check -m <MODEL> --config model_reasoning_effort="<EFFORT>" --dangerously-bypass-approvals-and-sandbox --json -o <AUDIT>/<slug>.last.md "$(cat <PROMPT>)" </dev/null > <AUDIT>/<slug>.log 2>&1` |
+| `STREAM` | `--json` (eventos JSONL) |
+| `AUTO` | `--dangerously-bypass-approvals-and-sandbox` (sem sandbox + sem approvals = full access **com rede**, p/ o CLI rodar o gate; justificavel porque a worktree e isolada). Edicao sem gate de rede: `--sandbox workspace-write --full-auto`. Somente leitura/analise: `--sandbox read-only` (sem `--full-auto`). |
+| `RESUME <id>` | `cd <WORKTREE> && codex exec resume <THREAD_ID> --skip-git-repo-check --dangerously-bypass-approvals-and-sandbox --json "$(cat <FOLLOWUP_PROMPT>)" </dev/null >> <AUDIT>/<slug>.log 2>&1` |
+| `RESUME_LAST` | `codex exec resume --last …` (filtra por cwd = a worktree) |
+| `SESSION_ID` | Codex **nao tem flag pra fixar** o id → **capture** o thread id do stream da 1a run: `grep -oE '"thread_id":"[^"]*"' <AUDIT>/<slug>.log \| head -1` (do evento `thread.started`) → grave em `<AUDIT>/<slug>.session`. |
+| `DONE_SIGNAL` | `{"type":"turn.completed"}` no stream log |
+| `USAGE` | `turn.completed.usage` → `input_tokens` / `cached_input_tokens` / `output_tokens` / `reasoning_output_tokens`. Extrair: `grep -oE '"usage":\{[^}]*\}' <AUDIT>/<slug>.log \| tail -1` |
+
+**Modelos (forte→leve):** `gpt-5.5` · `gpt-5.3-codex` · `gpt-5.4` · `gpt-5.3-codex-spark` · `gpt-5.4-mini`.
+**Effort:** `low` · `medium` · `high` · `xhigh`. Comece um degrau abaixo do teto; escale conforme a `dw-cli-run`.
+
+**Relatorio detalhado (recomendado):** adicione `--output-schema <schema.json>` exigindo um relatorio rico
+(`summary`/`tasks`/`filesChanged`/`gate`/`fenceViolations`/`uncommitted`/`blockers`/`nextSteps`) — nao aceite um
+"ok" opaco. O `codex-prompt.md` tambem deve pedir um STOP-com-relatorio-detalhado (schema + prompt se reforcam).
+
+## Resume de sessao (o coracao)
+1a run: capture o `thread_id` em `<AUDIT>/<slug>.session` (duravel, fora da worktree → sobrevive ao
+`git worktree remove`). Pra voltar com o **mesmo contexto**, leia o id e re-rode `RESUME <id>` com o prompt de
+follow-up — o Codex continua o mesmo thread (raciocinio + arquivos ja tocados). Fallback se o sidecar sumiu:
+`codex exec resume --last` da mesma worktree.
+
+## Variaveis de Input
+| Variavel | Descricao | Exemplo |
+|----------|-----------|---------|
+| `<WORKTREE>` | git worktree dedicada (off main) | `~/code/vizzita-billing-s10` |
+| `<PROMPT>` | caminho do prompt/spec preparado | `.dw/spec/prd-billing-integrador/codex-prompt.md` |
+| `<slug>` | chave da tarefa p/ arquivos de audit/sessao | `prd-billing-integrador` |
+| `<AUDIT>` | dir de auditoria duravel FORA da worktree | `~/code/vizzita/.dw/cli-run` |
+
+Retorne pelo **Structured Return** da `dw-cli-run` (Status/Score/Scope/Evidence/Artifacts/Decisions/Risks/
+Telemetria/Next Step), incluindo o `thread_id` capturado, o caminho do sidecar, e o comando `RESUME` exato pra
+continuar. Testado: codex-cli 0.141.0.
+</system_instructions>

package/scaffold/pt-br/commands/dw-copilot-run.md

@@ -0,0 +1,49 @@
+<system_instructions>
+Voce e o **adapter runner do Copilot**. Voce dispara o GitHub Copilot CLI (`copilot -p`) dentro de uma **git
+worktree dedicada** para implementar um prompt/spec ja preparado, captura a execucao inteira num log de auditoria
+duravel, mantem uma **sessao resumivel por tarefa**, da nota 0–10 a entrega, escala em caso de falha e **PARA para
+o gate**.
+
+<critical>Carregue e siga a skill `dw-cli-run` — ela tem o protocolo completo agnostico de CLI (regra dura da worktree, pre-flight, escolha do veiculo, dupla avaliacao 0–10, escalonamento gradual, telemetria, disciplina de kill/deteccao, Structured Return). Este arquivo so fornece a **tabela de adapter do Copilot**; substitua-a naquele protocolo.</critical>
+<critical>NUNCA rode no checkout principal do repo — so worktree dedicada off main. ABORTE (`BLOCKED`) caso contrario.</critical>
+<critical>NUNCA mergeie nem de push. Merge e decisao do dono, depois do gate.</critical>
+
+## Tabela de adapter do Copilot (substituir na `dw-cli-run`)
+
+| Slot | Valor Copilot |
+|---|---|
+| `DISPATCH` | `cd <WORKTREE> && copilot -p "$(cat <PROMPT>)" --allow-all --model <MODEL> --output-format json </dev/null > <AUDIT>/<slug>.log 2>&1` |
+| `STREAM` | `--output-format json` (registros JSONL) |
+| `AUTO` | `--allow-all` (auto-aprovacao de todo uso de tool/comando; justificavel porque a worktree e isolada). Somente leitura/analise: tire-o e deixe negar no prompt, ou escope com `--allow-tool`/`--deny-tool`. |
+| `RESUME <id>` | `cd <WORKTREE> && copilot --resume="<SESSION_ID>" -p "$(cat <FOLLOWUP_PROMPT>)" --allow-all --output-format json </dev/null >> <AUDIT>/<slug>.log 2>&1` (tambem: `--connect=<SESSION_ID>`) |
+| `RESUME_LAST` | `copilot --continue -p …` (continua a sessao mais recente nesta cwd) |
+| `SESSION_ID` | O `--resume`/`--session-id` do Copilot **RESUMEM** uma sessao existente (nao fixam uma nova) → **capture** o id da 1a run: varra o stream/log pelo registro do session id, ou leia o dir mais novo em `~/.copilot/logs` / `~/.copilot/history-session-state`. Grave em `<AUDIT>/<slug>.session`. **Confirme o campo exato do id no smoke test.** |
+| `DONE_SIGNAL` | o registro JSON final do stream (fim de turno) |
+| `USAGE` | o uso de tokens do registro final (confirme os nomes exatos dos campos no smoke test) |
+
+**Modelo:** `--model` escolhe a engine (ex.: `claude-sonnet-4.5`, `gpt-5`). O Copilot nao tem flag numerica de
+effort; mapeie "escalonamento" para o tier do modelo. Comece um tier abaixo do teto; escale conforme a `dw-cli-run`.
+
+## Resume de sessao (o coracao)
+O Copilot nao deixa fixar o id, entao na 1a run **capture** o session id (do stream/log ou `~/.copilot/logs`) e
+grave em `<AUDIT>/<slug>.session` (duravel, fora da worktree → sobrevive ao `git worktree remove`). Pra voltar com
+o **mesmo contexto**, leia o id e re-rode `RESUME <id>` (`copilot --resume="<id>" -p …` ou `--connect=<id>`) com o
+prompt de follow-up — o Copilot recarrega a mesma sessao. Fallback se o sidecar sumiu: `copilot --continue -p …`
+da mesma worktree.
+
+> **Confirmacoes no smoke test (conforme o plano):** o campo exato do session-id no JSONL, os nomes dos campos de
+> usage, e que `--resume=<id>` de fato continua o mesmo contexto — verifique numa worktree descartavel antes de
+> confiar, e atualize esta tabela com o que achar.
+
+## Variaveis de Input
+| Variavel | Descricao | Exemplo |
+|----------|-----------|---------|
+| `<WORKTREE>` | git worktree dedicada (off main) | `~/code/vizzita-billing-s10` |
+| `<PROMPT>` | caminho do prompt/spec preparado | `.dw/spec/prd-billing-integrador/codex-prompt.md` |
+| `<slug>` | chave da tarefa p/ arquivos de audit/sessao | `prd-billing-integrador` |
+| `<AUDIT>` | dir de auditoria duravel FORA da worktree | `~/code/vizzita/.dw/cli-run` |
+
+Retorne pelo **Structured Return** da `dw-cli-run` (Status/Score/Scope/Evidence/Artifacts/Decisions/Risks/
+Telemetria/Next Step), incluindo o `session-id` capturado, o caminho do sidecar, e o comando `RESUME` exato pra
+continuar.
+</system_instructions>

package/scaffold/pt-br/commands/dw-plan.md

@@ -39,6 +39,7 @@ Quando disponíveis em `./.agents/skills/`, use como suporte:
 - `dw-council` (opt-in via `--council`): stress-test multi-conselheiro sobre a decisão arquitetural principal no estágio TechSpec.
 - `dw-codebase-intel`: consultado para convenções de API, padrões arquiteturais, naming ao desenhar TechSpec.
 - `dw-search-first`: **OBRIGATÓRIO** antes de adicionar nova dependency, integration, MCP server, helper reutilizavel ou abstracao de framework.
+- `dw-minimalism`: **OBRIGATÓRIO** antes de especificar novos módulos/serviços — pressiona o escopo com o ladder YAGNI pro TechSpec não over-buildar; compõe com `dw-search-first`.
 - `dw-context-budget`: use quando o plano passar de 12 tasks, tocar 30+ arquivos, ou exigir carregar muitos docs/skills.
 
 ## Agent Dispatch

package/scaffold/pt-br/commands/dw-review.md

@@ -47,6 +47,7 @@ Quando disponíveis em `./.agents/skills/`, são invocadas como apoio analítico
 - `dw-secure-audit` (**Security Gate**): **SEMPRE para projetos TS/Python/C#/Rust** — acionado aqui e o verdict é enforced. Se a linguagem é suportada e `.dw/secure-audit/audit-summary.md` fresco está ausente OU REPROVADO, o verdict do review é **REPROVADO** — sem exceção. O mesmo gate também é comando standalone (`/dw-secure-audit`) e fase explícita no `/dw-autopilot`. Agora soma Semgrep SAST (diff) + gitleaks secrets sobre OWASP/Trivy/SCA.
 - `security-review`: a skill OWASP nível-diff que o gate usa (injection, authz, secrets, SSRF, crypto — só HIGH CONFIDENCE).
 - `dw-simplification`: use quando diff toca código denso — aplica Chesterton's Fence, protocolo de refactor preservando comportamento, métricas de complexidade.
+- `dw-minimalism`: use quando o diff adiciona código que pode estar over-built — flagra generalidade especulativa, helpers de um único caller, abstração prematura e violações de YAGNI (a contraparte pré-geração do `dw-simplification`).
 - `dw-ui-discipline`: use quando diff toca UI — roda os 14 visual-slop patterns + accessibility floor. Para um gate determinístico, rode também `node .dw/scripts/lib/ui-slop-detect.mjs <paths-ui-alterados> --fail-on error` (wrapper sobre o detector do impeccable); trate findings bloqueantes como **REJECTED** e reporte os warnings.
 - `dw-testing-discipline`: use quando diff toca testes — aplica catálogo de 25 anti-patterns + 6 agent guardrails (quando testes foram agent-authored).
 - `dw-llm-eval`: **OBRIGATÓRIO quando diff toca código de feature AI/LLM**. Reference dataset + ≥2 oracle rungs + judge calibration (se rung 4 usado) + eval run results DEVEM estar no PR. Faltando → REPROVADO.

package/scaffold/pt-br/commands/dw-run.md

@@ -35,6 +35,7 @@ Quando disponíveis em `./.agents/skills/`, estas skills são invocadas por task
 - `dw-testing-discipline`: aplica placement doctrine, 6 agent guardrails e 25 anti-patterns ao adicionar testes.
 - `dw-ui-discipline`: quando task toca UI, as 4 grounding questions precisam ser respondidas antes de qualquer decisão visual.
 - `dw-llm-eval`: quando task toca código de feature AI, regras de reference dataset + oracle ladder se aplicam.
+- `dw-minimalism`: **antes de escrever código novo** — sobe o decision ladder YAGNI (precisa existir? reusar? stdlib? nativo? dep instalada? uma linha?) na intensidade ativa, depois escreve o mínimo. Passa novas dependências pro `dw-search-first`.
 - `vercel-react-best-practices`: quando task toca performance React/Next.js.
 
 ## Constitution Gate

package/scaffold/pt-br/commands/dw-update.md

@@ -27,6 +27,8 @@ mkdir -p "$SNAPSHOT_DIR"
 cp -r .dw/commands .dw/templates .dw/references .dw/scripts "$SNAPSHOT_DIR/" 2>/dev/null
 # agents/skills (bundled) tambem fazem parte do update
 [ -d .agents/skills ] && cp -r .agents/skills "$SNAPSHOT_DIR/agents-skills" 2>/dev/null
+# .claude/settings.json agora e mutado pelo update (MCPs + hooks + statusLine)
+[ -f .claude/settings.json ] && mkdir -p "$SNAPSHOT_DIR/claude" && cp .claude/settings.json "$SNAPSHOT_DIR/claude/settings.json" 2>/dev/null
 echo "Snapshot salvo em $SNAPSHOT_DIR"
 ```
 
@@ -128,7 +130,7 @@ Se invocado com `--rollback`:
 1. Listar snapshots em `.dw/.backup/`
 2. Se nenhum existir: PARAR e reportar "Nenhum snapshot disponível"
 3. Se mais de um existir: perguntar ao usuário qual restaurar (padrão: mais recente)
-4. Confirmar com o usuário: "Restaurar snapshot `<path>`? Isso SOBRESCREVE `.dw/commands/`, `.dw/templates/`, `.dw/references/`, `.dw/scripts/` e `.agents/skills/`. Prosseguir? [s/N]"
+4. Confirmar com o usuário: "Restaurar snapshot `<path>`? Isso SOBRESCREVE `.dw/commands/`, `.dw/templates/`, `.dw/references/`, `.dw/scripts/`, `.agents/skills/` e `.claude/settings.json`. Prosseguir? [s/N]"
 5. Somente após `s`: copiar de volta
 
 ```bash
@@ -137,6 +139,7 @@ cp -r "$SNAPSHOT_DIR/templates"  .dw/
 cp -r "$SNAPSHOT_DIR/references" .dw/ 2>/dev/null
 cp -r "$SNAPSHOT_DIR/scripts"    .dw/ 2>/dev/null
 [ -d "$SNAPSHOT_DIR/agents-skills" ] && cp -r "$SNAPSHOT_DIR/agents-skills" .agents/skills 2>/dev/null
+[ -f "$SNAPSHOT_DIR/claude/settings.json" ] && cp "$SNAPSHOT_DIR/claude/settings.json" .claude/settings.json 2>/dev/null
 ```
 
 6. Reportar: snapshot restaurado, versão provavelmente recuperada (ler de `.dw/commands/dw-help.md` ou metadata se houver)

package/scaffold/scripts/hooks/git-guardrails.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * dev-workflow git guardrails — Claude Code PreToolUse hook (matcher: Bash).
+ *
+ * Blocks irreversible git commands (force push, hard reset, clean -f, branch
+ * deletion, remote branch deletion). Everything else is allowed.
+ *
+ * Enforces the destructive-command rules from the `dw-git-discipline` skill at
+ * the harness level instead of relying on prose. Inspired by mattpocock/skills
+ * `git-guardrails-claude-code` (MIT).
+ *
+ * Contract: reads the PreToolUse payload as JSON on stdin, emits a
+ * permissionDecision via hookSpecificOutput. Fails OPEN — any parsing/runtime
+ * error allows the command, so a hook bug never blocks the user.
+ */
+
+const DANGEROUS = [
+  { re: /\bgit\s+push\b[^\n|&;]*(--force\b|--force-with-lease\b|\s-f\b)/, why: 'force push rewrites remote history' },
+  { re: /\bgit\s+push\b[^\n|&;]*(--delete\b|\s-d\b|\s:\S)/, why: 'deletes a remote branch' },
+  { re: /\bgit\s+reset\b[^\n|&;]*--hard\b/, why: 'hard reset discards uncommitted work and rewrites the branch' },
+  { re: /\bgit\s+clean\b[^\n|&;]*-[a-z]*f/, why: 'git clean -f permanently deletes untracked files' },
+  { re: /\bgit\s+branch\b[^\n|&;]*\s-D\b/, why: 'force-deletes a branch that may be unmerged' },
+  { re: /\bgit\s+checkout\b[^\n|&;]*\s(--\s+\.|\.\s*$)/, why: 'discards all local changes in the working tree' },
+];
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    if (process.stdin.isTTY) return resolve('');
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => (data += chunk));
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', () => resolve(''));
+  });
+}
+
+function allow() {
+  process.exit(0);
+}
+
+function deny(reason) {
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: reason,
+      },
+    }) + '\n',
+  );
+  process.exit(0);
+}
+
+async function main() {
+  let payload;
+  try {
+    payload = JSON.parse(await readStdin());
+  } catch {
+    return allow(); // fail open
+  }
+
+  const command = payload && payload.tool_input && typeof payload.tool_input.command === 'string'
+    ? payload.tool_input.command
+    : '';
+  if (!command) return allow();
+
+  for (const rule of DANGEROUS) {
+    if (rule.re.test(command)) {
+      return deny(
+        `Blocked by dev-workflow git guardrails: ${rule.why}. ` +
+          `If this is intentional, run it yourself outside the agent, or adjust .claude/settings.json hooks.`,
+      );
+    }
+  }
+
+  return allow();
+}
+
+main().catch(() => allow());

package/scaffold/scripts/hooks/statusline.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * dev-workflow statusline — Claude Code statusLine command.
+ *
+ * Prints one line: git branch · dev-workflow active spec (if any) · minimalism
+ * mode. Reads the session payload (JSON on stdin) for the working dir; falls
+ * back to process.cwd(). Fails SAFE — any error prints a minimal line so the
+ * statusline never breaks the session.
+ *
+ * Minimalism mode is read from .dw/minimalism.json (see the dw-minimalism skill).
+ */
+
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    if (process.stdin.isTTY) return resolve('');
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', () => resolve(''));
+  });
+}
+
+function gitBranch(cwd) {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+      .toString()
+      .trim();
+  } catch {
+    return '';
+  }
+}
+
+function minimalismMode(cwd) {
+  try {
+    const file = join(cwd, '.dw', 'minimalism.json');
+    if (!existsSync(file)) return 'full';
+    const mode = JSON.parse(readFileSync(file, 'utf-8')).mode;
+    return typeof mode === 'string' ? mode : 'full';
+  } catch {
+    return 'full';
+  }
+}
+
+function activeSpec(cwd) {
+  try {
+    const specDir = join(cwd, '.dw', 'spec');
+    if (!existsSync(specDir)) return '';
+    const dirs = readdirSync(specDir, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name);
+    return dirs.length ? `spec:${dirs.length}` : '';
+  } catch {
+    return '';
+  }
+}
+
+async function main() {
+  let cwd = process.cwd();
+  try {
+    const payload = JSON.parse(await readStdin());
+    cwd =
+      (payload && payload.workspace && payload.workspace.current_dir) ||
+      (payload && payload.cwd) ||
+      cwd;
+  } catch {
+    /* use process.cwd() */
+  }
+
+  const parts = [];
+  const branch = gitBranch(cwd);
+  if (branch) parts.push(`⎇ ${branch}`);
+  const spec = activeSpec(cwd);
+  if (spec) parts.push(spec);
+  parts.push(`min:${minimalismMode(cwd)}`);
+
+  process.stdout.write(`dw · ${parts.join(' · ')}`);
+}
+
+main().catch(() => process.stdout.write('dw'));