@brunosps00/dev-workflow 1.2.0 → 1.3.0

package/README.md

@@ -26,7 +26,7 @@ npx @brunosps00/dev-workflow install-deps
 
 ## Commands
 
-dev-workflow v1.1.4 ships **33 commands** organized into four tiers. Most users only invoke Tier 1 + Tier 2.
+dev-workflow v1.3.0 ships **36 commands** organized into four tiers. Most users only invoke Tier 1 + Tier 2.
 
 ### Tier 1 — Gateway (3)
 
@@ -69,7 +69,7 @@ Use these when you want step-by-step control instead of `/dw-autopilot`.
 | **`/dw-install-azure-skills`** | **Opt-in.** Clones curated Azure skills from [`MicrosoftDocs/Agent-Skills`](https://github.com/MicrosoftDocs/Agent-Skills) (CC-BY-4.0) into `.agents/skills/azure/` and registers the [Microsoft Learn MCP Server](https://learn.microsoft.com/en-us/training/support/mcp-get-started) (HTTP, no-auth). Interactive category selection (Compute / Data & Storage / AI & ML / Networking / Identity & Security / DevOps / Observability / Integration / Architecture / All). Re-run to refresh from upstream. Also available as CLI: `npx @brunosps00/dev-workflow install-azure-skills`. |
 | **`/dw-install-aws-skills`** | **Opt-in.** Clones curated AWS skills from [`aws/agent-toolkit-for-aws`](https://github.com/aws/agent-toolkit-for-aws) (Apache 2.0) into `.agents/skills/aws/` and registers the unified [AWS MCP Server](https://docs.aws.amazon.com/aws-mcp/) (stdio via `uvx mcp-proxy-for-aws@latest`). **Requires `uv`, `aws cli ≥ 2.32.0`, and AWS credentials.** Interactive category selection (Core / Analytics / Database / EC2 / Migration / Networking / Operations / Security / Serverless / Storage / All). The agent gains `aws___call_aws` (executes 15,000+ AWS APIs) and `aws___run_script` (Python sandboxed) — review `.dw/references/aws-mcp-instructions.md` for the destructive-operations protocol. Also available as CLI: `npx @brunosps00/dev-workflow install-aws-skills [--region=<aws-region>]`. |
 
-### Tier 4 — Hidden/Internal (9)
+### Tier 4 — Hidden/Internal (12)
 
 These are auto-invoked by Tier 1-3 commands. Available standalone via `/dw-help --advanced`.
 
@@ -79,6 +79,9 @@ These are auto-invoked by Tier 1-3 commands. Available standalone via `/dw-help
 | **`/dw-intel "question"`** | Query codebase intelligence (`.dw/intel/`). `--build` (re)creates the index. | `/dw-plan`, `/dw-review`, `/dw-bugfix` |
 | **`/dw-secure-audit`** | **Security Gate** (phase after review/QA, before commit/PR): OWASP + Semgrep SAST (diff/generated code) + gitleaks secrets + Trivy SCA/IaC + lockfile + supply-chain + outdated. Rigoroso: secrets/CRITICAL/HIGH block (secrets have no ADR escape). Flags: `--scan-only`, `--plan`, `--execute`. See [docs/security-gate.md](docs/security-gate.md). | `/dw-review`, `/dw-autopilot` (explicit step), enforced by `/dw-generate-pr` |
 | **`/dw-goal "<objective>"`** | Durable objective contract. Uses Codex native `/goal` when available and `.dw/goals/` everywhere for Codex, Copilot, Claude Code, and OpenCode. | `/dw-autopilot` after planning |
+| **`/dw-claude-run`** | Fire `claude -p` (headless) in a dedicated git worktree to implement a prepared prompt/spec. Claude adapter over the `dw-cli-run` protocol: durable audit log, resumable session via `--session-id`, 0–10 dual evaluation, STOP for the gate. Never the main checkout; never merges. | manual delegation step |
+| **`/dw-codex-run`** | Fire `codex exec` in a dedicated git worktree to implement a prepared prompt/spec. Codex adapter over the `dw-cli-run` protocol: durable audit log, resumable per-task session, 0–10 dual evaluation, STOP for the gate. Never the main checkout; never merges. | manual delegation step |
+| **`/dw-copilot-run`** | Fire `copilot -p` (GitHub Copilot CLI) in a dedicated git worktree to implement a prepared prompt/spec. Copilot adapter over the `dw-cli-run` protocol: durable audit log, resumable session, 0–10 dual evaluation, STOP for the gate. Never the main checkout; never merges. | manual delegation step |
 | **`/dw-find-skills "query"`** | Searches `npx skills` ecosystem, vets, installs. | manual when extending the bundle |
 | **`/dw-update`** | Updates dev-workflow to latest npm release with rollback snapshot. | manual maintenance |
 | **`/dw-subtask-start`** | Creates a minimal input packet for a subagent without injecting the parent transcript. | parent agent before delegation |

package/lib/constants.js

@@ -5,7 +5,10 @@ const COMMANDS = {
     { name: 'dw-autopilot', description: 'Trigger when user asks to implement, build, create, or add a feature non-trivially. First invocation plans and stops; second invocation resumes via dw-goal, then commit and PR.' },
     { name: 'dw-brainstorm', description: 'Refine a concrete idea against the product\'s existing features. Modes: ideation, --research, --onepager, --council. Use dw-opportunities before you have an idea and dw-refactor for code-health audits.' },
     { name: 'dw-bugfix', description: 'Trigger when user reports a bug, pastes an error, or describes broken behavior. Triages with three questions, then fixes or routes to PRD.' },
+    { name: 'dw-claude-run', description: 'Trigger when user asks to run/fire Claude (claude -p headless) in a dedicated worktree to implement a prepared prompt/spec. Claude adapter over the dw-cli-run protocol: durable audit log, resumable session via --session-id, 0-10 dual evaluation, STOP for the gate. Never the main checkout; never merges.' },
+    { name: 'dw-codex-run', description: 'Trigger when user asks to run/fire Codex (codex exec) in a dedicated worktree to implement a prepared prompt/spec. Codex adapter over the dw-cli-run protocol: durable audit log, resumable per-task session, 0-10 dual evaluation, STOP for the gate. Never the main checkout; never merges.' },
     { name: 'dw-commit', description: 'Trigger when implementation is complete and pending changes need to be committed. Atomic commits with Conventional Commits messages.' },
+    { name: 'dw-copilot-run', description: 'Trigger when user asks to run/fire GitHub Copilot CLI (copilot -p) in a dedicated worktree to implement a prepared prompt/spec. Copilot adapter over the dw-cli-run protocol: durable audit log, resumable session, 0-10 dual evaluation, STOP for the gate. Never the main checkout; never merges.' },
     { name: 'dw-dockerize', description: 'Reads a project, detects the stack and runtime deps, then proposes Dockerfile and docker-compose for dev and prod with explicit trade-offs.' },
     { name: 'dw-find-skills', description: 'Searches the npx skills ecosystem for a skill matching what you need, vets it, and installs it where you choose.' },
     { name: 'dw-functional-doc', description: 'Maps screens and user flows into a functional doc, validated end-to-end with Playwright.' },
@@ -40,7 +43,10 @@ const COMMANDS = {
     { name: 'dw-autopilot', description: 'Trigger quando usuario pede pra implementar, criar ou adicionar uma feature nao-trivial. Primeira invocacao planeja e para; segunda retoma via dw-goal, depois commit e PR.' },
     { name: 'dw-brainstorm', description: 'Refina uma ideia concreta contra features existentes do produto. Modos: ideacao, --research, --onepager, --council. Use dw-opportunities antes de ter uma ideia e dw-refactor para auditoria de code health.' },
     { name: 'dw-bugfix', description: 'Trigger quando usuario reporta bug, cola erro ou descreve comportamento quebrado. Tria com tres perguntas, depois corrige ou roteia pra PRD.' },
+    { name: 'dw-claude-run', description: 'Trigger quando usuario pede pra rodar/disparar o Claude (claude -p headless) numa worktree dedicada pra implementar um prompt/spec preparado. Adapter Claude sobre o protocolo dw-cli-run: log de auditoria duravel, sessao resumivel via --session-id, dupla avaliacao 0-10, PARA pro gate. Nunca no checkout principal; nunca mergeia.' },
+    { name: 'dw-codex-run', description: 'Trigger quando usuario pede pra rodar/disparar o Codex (codex exec) numa worktree dedicada pra implementar um prompt/spec preparado. Adapter Codex sobre o protocolo dw-cli-run: log de auditoria duravel, sessao resumivel por tarefa, dupla avaliacao 0-10, PARA pro gate. Nunca no checkout principal; nunca mergeia.' },
     { name: 'dw-commit', description: 'Trigger quando implementacao esta completa e ha mudancas pendentes pra commit. Commits atomicos com mensagens Conventional Commits.' },
+    { name: 'dw-copilot-run', description: 'Trigger quando usuario pede pra rodar/disparar o GitHub Copilot CLI (copilot -p) numa worktree dedicada pra implementar um prompt/spec preparado. Adapter Copilot sobre o protocolo dw-cli-run: log de auditoria duravel, sessao resumivel, dupla avaliacao 0-10, PARA pro gate. Nunca no checkout principal; nunca mergeia.' },
     { name: 'dw-dockerize', description: 'Le um projeto, detecta stack e deps de runtime, e propoe Dockerfile e docker-compose para dev e prod com trade-offs explicitos.' },
     { name: 'dw-find-skills', description: 'Busca no ecossistema npx skills uma skill que resolva o que voce precisa, valida e instala onde voce escolher.' },
     { name: 'dw-functional-doc', description: 'Mapeia telas e fluxos em um dossie funcional, validado E2E com Playwright.' },

package/lib/skill-registry.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const { COMMANDS } = require('./constants');
 const { readJson } = require('./utils');
 
 const SCAFFOLD_DIR = path.join(__dirname, '..', 'scaffold');
@@ -42,6 +43,7 @@ function validateSkillRegistry() {
   const warnings = [];
   const entriesByName = new Map();
   const scaffoldNames = new Set(listScaffoldSkillNames());
+  const commandNames = new Set(Object.values(COMMANDS).flat().map((cmd) => cmd.name));
 
   for (const entry of registry.skills) {
     validateEntry(entry, issues);
@@ -50,6 +52,10 @@ function validateSkillRegistry() {
     }
     entriesByName.set(entry.name, entry);
 
+    if (commandNames.has(entry.name)) {
+      issues.push(`Skill registry entry collides with command wrapper name: ${entry.name}`);
+    }
+
     if (!scaffoldNames.has(entry.name)) {
       issues.push(`Skill registry references missing scaffold skill: ${entry.name}`);
       continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunosps00/dev-workflow",
-  "version": "1.2.0",
+  "version": "1.3.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"

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/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/skill-registry.json

@@ -24,25 +24,25 @@
       "bundled": true
     },
     {
-      "name": "dw-codebase-intel",
+      "name": "dw-cli-run",
       "kind": "protocol",
       "tier": "core",
-      "owner": "dw-intel",
-      "trigger": "Codebase indexing or codebase intelligence query",
-      "expected_output": ".dw/intel index files or a cited answer from the index.",
+      "owner": "dw-codex-run,dw-claude-run,dw-copilot-run",
+      "trigger": "Fire an AI CLI (Codex/Claude/Copilot) in a dedicated git worktree to implement a prepared prompt; resumable per-task session; STOP for the gate",
+      "expected_output": "Audit-logged run with a 0-10 dual evaluation, a resumable session-id sidecar, and a STOP-for-gate Structured Return.",
       "load_policy": "lazy-references",
-      "context_limit": 12000,
+      "context_limit": 18000,
       "bundled": true
     },
     {
-      "name": "dw-context-budget",
+      "name": "dw-codebase-intel",
       "kind": "protocol",
       "tier": "core",
-      "owner": "dw-context-budget",
-      "trigger": "Context overhead, slow sessions, many agents/skills/MCPs",
-      "expected_output": "A context budget report with concrete savings.",
-      "load_policy": "always-small",
-      "context_limit": 6000,
+      "owner": "dw-intel",
+      "trigger": "Codebase indexing or codebase intelligence query",
+      "expected_output": ".dw/intel index files or a cited answer from the index.",
+      "load_policy": "lazy-references",
+      "context_limit": 12000,
       "bundled": true
     },
     {

package/scaffold/skills/dw-cli-run/SKILL.md

@@ -0,0 +1,217 @@
+---
+name: dw-cli-run
+description: "Shared runner protocol for the dw-*-run commands (dw-codex-run / dw-claude-run / dw-copilot-run). Fires an autonomous AI CLI (Codex / Claude / Copilot) INSIDE a dedicated git worktree to implement a prepared prompt/spec, with streaming captured to a durable audit log, a resumable per-task session, a 0–10 dual evaluation, graded escalation, and a STOP for the human gate. Loaded by those commands — substitute the CLI-specific adapter table they supply. NEVER runs in the main checkout; NEVER auto-merges (the owner decides after the gate)."
+allowed-tools:
+  - Bash
+  - Read
+  - AskUserQuestion
+---
+
+# dw-cli-run — fire an AI CLI in the right worktree, audit it, keep the session, stop for the gate
+
+CLI-**agnostic** core protocol for the delegation step of `dw-codex-run` / `dw-claude-run` / `dw-copilot-run`: a
+**git worktree** holds a **prompt/spec** already prepared → this protocol fires the autonomous CLI there
+(streaming, non-blocking) → **captures the whole run to a durable audit log** → **keeps a resumable per-task
+session** → **evaluates the delivery 0–10** → escalates on failure → **STOPS for the gate** (merge is the owner's
+call). It exists because running these CLIs by hand is repetitive and risky: wrong worktree, hangs without a TTY,
+lost audit trail, and forgetting to measure quality before merge.
+
+> **Dual-use:** these CLIs perform **autonomous edits with auto-approve**. Confirm the **right worktree** and the
+> **scope** before firing. The isolated worktree is the mitigation that justifies the auto-approve flag.
+
+## The adapter table (supplied by the invoking command)
+The command that loaded you (`dw-codex-run` / `dw-claude-run` / `dw-copilot-run`) provides a **CLI adapter table**
+with these slots. Substitute them into the steps below — everything else is identical across CLIs:
+
+| Slot | Meaning |
+|---|---|
+| `DISPATCH` | first-run command (background, streaming → audit log, `</dev/null`) |
+| `STREAM` | flag(s) that make it emit parseable streaming events (JSON/JSONL) |
+| `AUTO` | auto-approve / non-interactive flag (justified by the isolated worktree) |
+| `RESUME <id>` | re-run command that **continues the SAME session/context** by id |
+| `RESUME_LAST` | "resume the last session of this cwd" fallback |
+| `SESSION_ID` | how to obtain/fix the session-id (from the stream, a sidecar, or a flag) |
+| `DONE_SIGNAL` | the stream event that means the turn finished |
+| `USAGE` | where token usage appears in the stream |
+
+If the command did not supply an adapter table, return `BLOCKED` — this skill is not invoked standalone.
+
+## RULE (hard) — never the main thread / main checkout
+Run **only** inside a **dedicated git worktree** (off main). **NEVER** fire the CLI in the repo's **main checkout**
+(the root tree on the primary branch, e.g. `~/code/<project>` on `main`) — the CLI edits autonomously and that
+would corrupt the owner's active tree. If the target is the main checkout, **ABORT** (`BLOCKED`) and instruct:
+create/use a worktree first (`git worktree add ../<project>-<slug> -b <branch> main`). Mandatory check before
+running: `git worktree list` → the target is a secondary worktree (not the one flagged as main) **AND** the CLI's
+`cwd` is that worktree.
+
+## Pre-flight (fail early > run in the wrong place)
+1. `<cli> --version` answers (CLI + credentials present). Missing → `BLOCKED`.
+2. `git worktree list` — confirm the target worktree and that it is **not** the main checkout.
+3. A **prompt/spec** exists (what the CLI receives). Common conventions: `.dw/spec/<slug>/codex-prompt.md`
+   (dev-workflow), `PROMPT.md`, `TASK.md`, or a path the owner names. **Read it** — it is the scope/fence/gate.
+
+## Where to run — pick the VEHICLE (the main thread NEVER runs inline)
+The main thread **orchestrates**; execution goes to one of these:
+- **Workflow (PREFERRED)** — when there is a pipeline (CLI implements → evaluate 0–10 → **gate fan-out**). One
+  workflow agent runs the CLI (network OK). Shows in `/workflows` + parallelizes. Structure as separate
+  **phases/agents**: `[agent that runs the CLI]` → `[gate agents]`.
+- **Single Agent (subagent)** — one-off dispatch of ONE run, no gate fan-out. Lighter; background; returns the
+  report. Does not show in `/workflows`.
+- **Background Bash** — fallback only (no workflow/agent harness). Needs network → run un-sandboxed so the CLI can
+  reach its API.
+
+> **Nesting:** the agent running the CLI **must not spawn further subagents** (nesting limit; Workflow nests only
+> 1 level). The gate is **another phase/agent** of the workflow — never a sub-spawn from inside the runner agent.
+
+## Protocol
+1. **Resolve target.** Worktree + prompt path (from the user or inferred). Derive a `<slug>` (the spec slug or
+   worktree tag) — it keys the durable audit log and the session sidecar.
+2. **Model + effort — the parent SIZES the complexity and proposes.** Read the prompt and size it; **propose**
+   model+effort with a one-line rationale (CLI-specific names live in the adapter table); the owner confirms or
+   overrides; if told "you pick", decide by heuristic. Signals: number of tasks; fence breadth; sensitive surface
+   (auth/security/tenant/migration/financial); "foundation/redesign/architectural" vs "mechanical fix/typo/docs";
+   E2E/secure-audit in the gate. Start **one notch below the ceiling** and escalate on failure (see Escalation).
+3. **Set up the durable audit dir (OUTSIDE the worktree).** `<AUDIT>=<main-repo-or-home>/.dw/cli-run/` — it MUST
+   survive `git worktree remove` (the worktree's `QA/` is wiped on merge). Files: `<AUDIT>/<slug>.log` (stream),
+   `<AUDIT>/<slug>.session` (session-id sidecar), optionally `<AUDIT>/<slug>.last.md` (final message).
+4. **Dispatch (first run) in BACKGROUND with streaming → durable audit log.** Use the adapter's `DISPATCH`:
+   ```bash
+   cd <WORKTREE> && <DISPATCH ... STREAM AUTO ... "$(cat <PROMPT_PATH>)"> </dev/null \
+     > <AUDIT>/<slug>.log 2>&1     # durable streaming audit trail
+   ```
+   - `</dev/null` ALWAYS (no TTY → hang). `STREAM` = parseable events; **don't** swallow everything with
+     `2>/dev/null`.
+   - **The stream log IS the audit trail (always capture).** It records, live and progressively, EVERYTHING the
+     CLI does: each shell `command`, item started/completed, the CLI's `agent_message` (reasoning + answers),
+     tool-calls, and the final `DONE_SIGNAL` (with `USAGE`/tokens). A "last message" capture (`-o` and friends)
+     holds only the **final** message; the stream holds the **whole path**.
+   - **Durability (critical for "audit later"):** write the stream log to a dir **outside** the worktree (step 3).
+     If it lived in the worktree's `QA/`, post-merge cleanup would delete it and the audit would vanish. Audit
+     later: shell commands `grep -oE '"command":"[^"]*"' <log>`; CLI reasoning/answers `grep '"agent_message"'
+     <log>`; tokens via the adapter's `USAGE` field; a readable transcript = `agent_message` + `command` in file
+     order.
+5. **SESSION PER TASK (the heart) — capture on first run, resume by id.**
+   - **First run:** obtain the **session-id** per the adapter's `SESSION_ID` (from the stream, a sidecar, or a
+     fixed flag) and write it to the durable sidecar `<AUDIT>/<slug>.session` (one line: the id). This sidecar
+     lives outside the worktree → it survives `git worktree remove`.
+   - **Resume the SAME context:** read `<AUDIT>/<slug>.session` and re-run the adapter's `RESUME <id>` with the
+     follow-up prompt → the CLI continues the **same session/context** (its reasoning, the files it already
+     touched, the gate state). This is how "come back to the C6 run with full context" works: re-run with the id.
+   - **Fallback:** if the sidecar is missing, the adapter's `RESUME_LAST` resumes the last session of this cwd
+     (worktree = the session's cwd), so context is recoverable as long as you run from the same worktree.
+   - Always record the session-id + sidecar path in the Structured Return (Artifacts) so a later turn can resume.
+6. **Detect "DONE" — by the stream, NEVER by `pgrep` of the worktree path.** The done signal is the adapter's
+   `DONE_SIGNAL` in the stream log **+** the worktree showing a commit/report (`git -C <worktree> log`, last
+   message filled). A `pgrep -f "<worktree-path>"` (or `-f "<...>/last-message"`) **self-matches your own grep
+   command** (the path is in the grep's argv) → false "running" that can hold a **READY** delivery for hours (and
+   a `until ! pgrep ...` waiter with that pattern **never terminates**, since it sees itself alive). In background
+   (`run_in_background`/Workflow), the **completion notification** is the signal. If you truly need pgrep,
+   restrict to `pgrep -af "<cli> "` and filter `/proc/<pid>/cmdline` — never pgrep the raw path.
+7. **Gate needs network?** Auto-approve modes that keep a sandbox **block network** for the CLI's shell commands →
+   `install`/build/test/E2E fail with `EAI_AGAIN`. If the prompt tells the CLI to run the gate, the adapter's
+   `AUTO` flag must be the **network-allowed** variant (full access) so the CLI runs the gate and self-validates.
+   Justified because the **hard RULE** guarantees an isolated worktree. Without network in the gate, the CLI only
+   implements and reports `blockers` (the gate then sits with the parent).
+8. **Read-only / analysis mode:** when only reviewing (no edits), use the adapter's read-only variant and drop the
+   auto-edit flag.
+
+## Mandatory evaluation — 0–10 score (ALWAYS)
+When the run finishes, the parent **evaluates the delivery and gives a 0–10 score** (10 = full conformance +
+complete delivery). Do not skip it — it is the signal that decides gate vs escalation. Score against the prompt:
+- **Scope/fence conformance** (did the ask; stayed inside the allowlist).
+- **Technical gate** (lint/test/build/E2E per the prompt — green?).
+- **Completeness** (every task/item delivered).
+- **Hygiene** (committed, no junk, nothing outside the fence, no forbidden deps).
+- **Quality / no regression.**
+**Acceptance bar: score ≥9** (owner's decision). Bands: **≥9** = acceptable (ready for the human gate); **6–8** =
+`FINDINGS` → **escalate** to reach ≥9; **<6** = failure → **escalate**. `BLOCKED` if the ladder is exhausted
+without reaching 9. Always show the score + a short per-criterion rationale.
+
+## Dual evaluation: the CLI auto-gates (MAX effort) → Claude re-gates (compares scores)
+The CLI **can't grade its own exam alone** — hence two layers. The CLI auto-gates cheaply (close to the work) and
+**Claude audits independently** and **compares the scores** (catches an inflated self-score).
+1. **CLI auto-gate (loop, MAX effort).** The prompt MUST instruct: after implementing, **run the SAME gate** and
+   give a **self-score 0–10**; **fix and re-run while the self-score <9 or the gate isn't green**, at max effort.
+   Stop at self-score ≥9 + green gate (or report `blockers`). The final report carries the self-score + per
+   criterion.
+2. **Claude re-gate (independent).** When the CLI declares pass, the parent **re-runs the SAME gate** (fan-out,
+   prefer Workflow → `/workflows`) and gives its **own 0–10** — without trusting the self-score.
+3. **Compare + decide.** Claude ≥9 and small gap → **PASS** (ready for the owner's merge decision). Claude <9 OR a
+   large gap (CLI overestimated) → re-execute: hand the gaps back via **session resume** (step 5, max effort) and
+   repeat 1→2→3 until it converges. **The score that counts for acceptance is Claude's**; the self-score is signal
+   + an inflation detector. Always record both scores + the gap in the Structured Return.
+
+## Graded escalation on failure
+If the score is low / the gate failed / the CLI didn't finish, **re-run the SAME task one notch up** — gradual, no
+giving up on the first stumble, no jumping to the top.
+- **Ladder (one at a time):** first **effort** low→medium→high→xhigh (adapter names them); exhausted, bump the
+  **model** one tier and reset effort to high. Re-run and **re-score**.
+- **Continue vs restart:** coherent partial edits → **resume the session** (step 5, keeps context). Broken/dirty
+  worktree → **reset first** (`git -C <worktree> reset --hard && git clean -fd`) and run fresh at the higher notch
+  — don't stack error on error.
+- **Stop:** at **score ≥9** (ready for the gate) OR when **exhausted** (strongest model + max effort still below)
+  → `BLOCKED` with evidence. Announce each notch; with autonomy, escalate to the ceiling yourself.
+
+## Detailed output → direct the next step
+The delivery must be **detailed enough for the parent to decide the next step** — not an opaque "done". When it
+finishes: **read the final message in full** + scan the stream; complement with `git -C <worktree> status` and
+`git diff --stat` to see what truly changed (don't trust only what the CLI said). Then **produce a HANDOFF**: what
+the **gate** should focus on, what to **adjust/redo**, whether to **escalate**, what's **outside the fence /
+uncommitted**, and the **blockers** — record it in the Structured Return (Evidence/Artifacts/Next Step). If the
+report is shallow, treat as `FINDINGS` and ask for detail (resume) or reconstruct it from the diff first.
+
+## Telemetry (tokens + time) — always report
+The stream ends with the adapter's `USAGE` block (token counts). Extract it from the log.
+- **Effective billable ≈ `(input − cached_input) + output`** — input is often ~95%+ cache; reporting only the raw
+  number misleads. Show both (raw + effective).
+- **Wall-clock:** the done event usually carries no duration → measure it yourself: wrap the dispatch with
+  `/usr/bin/time` or `date +%s` before/after. Report in minutes.
+- **Command count:** `grep -c '"command"' <log>` (effort proxy).
+- Record all of it under Structured Return → Telemetry. Useful for cost, escalation, and comparing fan-out phases.
+
+## Discipline (when finishing)
+- **STOP — not merged.** The CLI implemented in the worktree; **run the gate** (tests/lint/build + review; if the
+  project uses dev-workflow: `/dw-review` + `/dw-qa` + `/dw-secure-audit`) **before** any merge.
+- **Merge = the owner's explicit decision.** Never automatic here.
+- Flag **uncommitted** work or edits **outside the fence**.
+- **Stop/abort a running CLI:** use **`TaskStop <task_id>`** (if `run_in_background`/Workflow) OR
+  **`git worktree remove --force <worktree>`** (pulls the rug — the CLI has nowhere to write and dies). Fallback:
+  `kill -9` **only** the PIDs from `pgrep -af "<cli> "` whose `/proc/<pid>/cmdline` matches the worktree tag.
+  **NEVER walk UP the process tree (ppid → ppid…) to kill "the supervisor":** the background CLI is a **child of
+  the Claude session itself** (`<cli> ← claude ← bash ← init`) → killing the ancestors **takes down the session**.
+  Apparent "respawns" are just the node workers of ONE run.
+
+## Anti-patterns
+- Running in the main checkout / without confirming the worktree — corrupts the active tree. *(pre-flight 2)*
+- Merging/pushing inside the skill — merge lives outside, after the gate.
+- Skipping the 0–10 score — loses the quality/escalation signal.
+- Suppressing all output (or not capturing the stream to a log) — loses the audit of what the CLI did.
+- **Detecting "done" by `pgrep` of the worktree path** — self-matches your own command → false "running" that
+  holds ready deliveries. Use `DONE_SIGNAL` + worktree. *(step 6)*
+- **Killing the CLI by walking up the PID tree** — takes down the Claude session. Use `TaskStop`/`worktree
+  remove`. *(Discipline)*
+- Losing the session-id — without the sidecar you can't resume the SAME context; capture it on the first run.
+
+## Structured Return
+- **Status:** `PASS` · `FINDINGS` · `BLOCKED` · `NOT_APPLICABLE` — `PASS` = ran, score ≥9, stopped clean in the
+  right worktree, ready for the gate; `FINDINGS` = ran, score 6–8 or caveats (uncommitted/out-of-fence/partial);
+  `BLOCKED` = missing CLI/credential/worktree/prompt/adapter table, or escalation exhausted without reaching 9;
+  `NOT_APPLICABLE` = no worktree+prompt → still planning.
+- **Score:** **Claude's score** (0–10 — counts for acceptance, bar ≥9) + the **CLI self-score** + the **gap**;
+  per-criterion rationale (conformance/gate/completeness/hygiene/quality). Large gap = inflated self-score.
+- **Scope:** worktree + branch + prompt used; CLI + model + effort + sandbox/auto mode; escalation notches taken.
+- **Evidence:** path of the durable audit log + final-message file; stream JSONL excerpt; `git status`/diff of the
+  worktree post-run.
+- **Artifacts:** files created/changed (diff summary); **the session-id + sidecar path** (`<AUDIT>/<slug>.session`)
+  so a later turn can resume; the durable audit log path.
+- **Decisions:** model/effort and why; implementation vs read-only; continue (resume) vs reset on retry.
+- **Risks:** out of fence, uncommitted, gate not run, dual-use (autonomous edits).
+- **Telemetry:** tokens from the done event (input/cached/output/reasoning + **effective billable**) + **wall-clock**
+  + command count.
+- **Next Step:** "run the gate in the worktree; merge is the owner's decision" — and the exact resume command
+  (`RESUME <id>`) to continue this session.
+
+## Notes
+The CLI-specific flag names, model list, resume form, and session-id capture live in the **adapter table** of the
+invoking command (`dw-codex-run` / `dw-claude-run` / `dw-copilot-run`). This skill holds the CLI-agnostic protocol
+only; substitute the adapter slots and everything above applies unchanged.

package/scaffold/skills/dw-context-budget/SKILL.md

@@ -1,57 +0,0 @@
----
-name: dw-context-budget
-description: Audit context overhead from commands, skills, agents, MCPs, and instruction files before sessions degrade.
-allowed-tools:
-  - Read
-  - Grep
-  - Glob
-  - Bash
----
-
-# dw-context-budget
-
-Use when a project has many commands, skills, agents, MCP servers, or long instruction files.
-
-## Audit Targets
-
-- `CLAUDE.md` and `AGENTS.md`
-- `.dw/commands/*.md`
-- `.agents/skills/*/SKILL.md`
-- `.agents/agents/*.md`
-- `.claude/agents/*.md`
-- `.opencode/agent/*.md`
-- `.claude/settings.json`
-
-## Heuristics
-
-- Prose estimate: `word count * 1.3`
-- JSON/code estimate: `character count / 4`
-- Flag command files over 20KB
-- Flag `SKILL.md` files over 12KB
-- Flag agent files over 8KB
-- Flag more than 10 configured MCP servers
-- Flag duplicate copies loaded by more than one platform when a fallback would be enough
-
-## Report
-
-Return:
-
-1. Estimated overhead by category.
-2. Top 10 largest files.
-3. Duplicate or overlapping components.
-4. Top 5 concrete savings.
-5. What must remain loaded because commands depend on it.
-
-Inspired by ECC's `context-budget` and `strategic-compact` patterns; adapted for dev-workflow's `.dw/` scaffold and cross-platform wrappers.
-
-## Structured Return
-
-When invoked directly or by a harness, return or merge this block:
-
-- **Status:** `PASS` when the budget is acceptable, `FINDINGS` when concrete savings exist, `BLOCKED` when files cannot be measured, `NOT_APPLICABLE` when context budget is not relevant.
-- **Scope:** commands, skills, agents, MCPs, and instruction files measured.
-- **Evidence:** largest files, duplicate content, loaded references, and approximate byte/token cost.
-- **Artifacts:** report path or inline budget table.
-- **Decisions:** what stays loaded, what moves behind lazy references, and what can merge/remove.
-- **Risks:** losing trigger clarity, hiding required instructions, or creating stale references.
-- **Next Step:** top compaction action with expected savings.