@brunosps00/dev-workflow 2.0.0 → 2.2.0

package/.claude-plugin/marketplace.json

@@ -1,5 +1,6 @@
 {
   "name": "brunosps00-dev-workflow",
+  "description": "À-la-carte dev-workflow skills for focused agent work: minimalism, search-first research, verification, security review, and code quality.",
   "owner": {
     "name": "Bruno Santos"
   },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "dev-workflow",
   "description": "Standalone, à-la-carte skills from the dev-workflow pipeline: minimalism, search-first, simplification, verification, security review, and more.",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "author": {
     "name": "Bruno Santos"
   },

package/CHANGELOG.md

@@ -10,6 +10,182 @@ project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 > those versions were released, so they are summaries of what shipped, not
 > contemporaneous release notes. `git log` remains the authoritative record.
 
+## [2.2.0] — 2026-08-24
+
+Release driven by two operational failures observed on a real project, both of the
+same family: the pipeline was good at *starting* long work and silent about what
+happened next. Delegated runs gave no visibility until someone asked "any news?",
+and the worktrees those runs lived in were created by a hard rule and removed by
+nobody — 35 of them (33 already merged) were sitting on disk at 40 GB with the
+root filesystem at 95%. Both fixes are deterministic where prose had failed.
+
+### Added
+
+- **`/dw-report` — timestamped progress loop for long work.** Every 10 minutes
+  (`--every <N>m`) it emits a report with a real `date` timestamp saying what is
+  **done** (cumulative, new items marked `➕`, each with evidence: file, commit,
+  test count), what is **being done** (with a measurable figure — step counter,
+  files touched, running command and elapsed time — never a bare "in progress"),
+  and what is **left** (ordered, next milestone first, remaining gates included).
+  Reports go to the chat and are appended to `.dw/reports/YYYY-MM-DD.md`. The
+  cadence is the user's: it never stretches to "wait for the build"; a report
+  saying "nothing changed, ~4 min left" is the product while work runs. Silence is
+  reserved for the blocked/idle state (the transition to blocked reports once);
+  completion produces a final report immediately and disarms the loop. Vehicle is
+  the harness's native scheduled wake-up when available, a background `sleep`
+  timer otherwise, and never a system cron (which keeps firing for days after the
+  work ended). Auto-armed by `/dw-run`, `/dw-autopilot` (execution invocation), and
+  the `dw-cli-run` adapters; `DW_REPORT_AUTO=off` opts out and `DW_REPORT_BELL`
+  hooks a local sound or notification. `now`, `status`, `stop` modes.
+- **`/dw-worktree` — the lifecycle the runner adapters never had.** Backed by
+  `.dw/scripts/lib/worktree-gc.mjs` (Node, no dependencies), which resolves the
+  main checkout from anywhere in the repo. `list` gives every secondary worktree a
+  verdict — `REMOVABLE` (head is an ancestor of an integration branch, clean, no
+  process has its cwd inside, not locked), `KEEP:unmerged`, `KEEP:dirty`,
+  `KEEP:in-use`, `KEEP:locked`, `KEEP:recent`, `PRUNABLE` — with apparent size,
+  age, and dirty count; `--strict` exits 3 on leftovers. `clean` is a **dry-run by
+  default**; `--apply` removes only `REMOVABLE` entries, deletes their branches
+  (verified merged), and prunes. `create <slug>` enforces the `../<project>-<slug>`
+  convention and runs the install/build prep (lockfile-detected or
+  `.dw/config.json` `worktree.prep`) so a delegated agent never runs blind.
+  `merge <slug>` performs the safe order from the main checkout — ff-only merge →
+  remove → branch delete → prune — and aborts **before** the merge if the main
+  checkout is off the base branch or dirty, the worktree is dirty or in use, or
+  the merge is not a fast-forward. It never uses `--force` and never changes the
+  owner's active branch. Base resolution: `--base` → `DW_WORKTREE_BASE` →
+  `worktree.base` → `origin/HEAD` → `develop` → `main` → `master`.
+
+### Changed
+
+- **End of life is the same turn as the merge.** `dw-cli-run` pre-flight creates
+  missing worktrees through `/dw-worktree create`, and its Discipline section now
+  carries the hard rule: merged → `/dw-worktree merge` (or `clean --apply`) in
+  that same turn. The three adapters point their `<WORKTREE>` input at the same
+  commands. `/dw-pause` sweeps worktrees and treats every `REMOVABLE` entry as an
+  open loop to close now rather than record; `/dw-harness-audit` gained a
+  *Worktree hygiene* category scored from `list --strict`.
+- **git guardrails** (`scaffold/scripts/hooks/git-guardrails.mjs`) also block
+  `git worktree remove --force` / `-f`; plain `remove` and `prune` stay allowed.
+- `/dw-run` (all-tasks and `--resume`) and `/dw-autopilot` Step 8 arm the progress
+  loop before dispatching; `dw-help`, the agent-instructions trigger map, and the
+  README register both commands (41 commands, Tier 2 = 11, Tier 3 = 14).
+- `dw-cli-run` `context_limit` raised 19000 → 20500 to hold the two new sections.
+
+### Fixed
+
+- `init`/`update` now create `.dw/cli-run/.gitignore` (`*`, `!.gitignore`). The
+  adapters' durable audit logs, session sidecars, and last-message captures were
+  being committed and then checked out into every worktree (219 tracked files on
+  the project that motivated this release). Existing projects untrack them with
+  `git rm -r --cached .dw/cli-run`.
+- `init`/`update` create `.dw/reports/.gitignore` so the daily report logs and the
+  loop's `.active.json` stay machine-local while other reports (e.g.
+  `context-budget.md`) remain tracked.
+
+## [2.1.0] — 2026-08-04
+
+Release driven by a skill-by-skill analysis of [mattpocock/skills](https://github.com/mattpocock/skills),
+whose philosophy is the opposite of this project's: small composable skills anchored
+to an issue tracker, against an opinionated pipeline with durable state in `.dw/`.
+What follows is the transferable technique, adapted — plus five defects of our own
+that the comparison exposed. What was deliberately **not** taken, and why, is
+recorded in [docs/skills-ecosystem-comparison.md](docs/skills-ecosystem-comparison.md).
+
+### Added
+
+- **`/dw-triage` — the intake boundary the pipeline never had.** External bug
+  reports, feature requests, and PRs previously had to be hand-converted into a
+  bugfix or a PRD before anything could touch them. One category (`bug` |
+  `enhancement`) and one state (`needs-triage` → `needs-info` | `ready-for-work` |
+  `needs-human` | `wontfix`), persisted in `.dw/triage/NNN-<slug>.md`, routing to
+  `/dw-bugfix`, `/dw-plan prd`, or `/dw-brainstorm --mode=grill`. Two mechanisms
+  carry the weight: **claims are verified before a brief is written** (bugs
+  reproduced from the reporter's steps, PR diffs checked against what they claim),
+  and `.dw/out-of-scope/<concept>.md` remembers rejections **by domain concept**
+  rather than by the request's wording, so a request refused in January is not
+  re-litigated in March. A `wontfix` for "already implemented" deliberately does
+  not write there — that store is memory of refusal, not of delivery.
+  It is local-first in the strict sense: `.dw/` is the source of truth and the
+  command works with no network and no `gh`. GitHub read via `gh` is optional
+  enrichment, and writing back is opt-in per write, never a side effect of triage.
+- **`### Decision Map` in the idea one-pager.** `dw-grilling` already instructed
+  the agent to record its decision tree so a session could resume — with nowhere
+  to record it, so the graph was rebuilt from scratch every time and what the last
+  session knew was still *undecided* was lost. Each node now carries a `State`
+  (`resolved` | `open-ready` | `open-blocked`), a `Depends on:` field reusing the
+  form `tasks.md` already uses, and an explicit `**Frontier:**` line so the next
+  session reads what is decidable now without recomputing the graph. `#### Decision
+  Fog` records what is known to be undecided but not yet sharp enough to phrase as
+  a decision. Grill resumes from the map instead of re-deriving it, never re-asks a
+  `resolved` node, and the alignment gate now also requires `Frontier: none`.
+  Schema stays at `1.1`: the section is optional, so existing one-pagers stay valid.
+- **`/dw-review --since <ref>`** — ad-hoc review against a verified comparison
+  point. Resolves the ref with `git rev-parse --verify`, aborts with an actionable
+  message if it does not resolve, aborts if the diff is empty rather than reviewing
+  nothing, and records the exact diff and commit commands in every report so the
+  review is reproducible. Three-dot, matching PR review semantics. The default
+  PRD/bugfix flow is unchanged.
+- **Test-first loop in `dw-testing-discipline`** (`references/tdd-loop.md`):
+  confirm the public seam with the user, one red test per vertical slice, run it
+  and **observe** the expected red, minimum green, next slice. Refactor is outside
+  the cycle. `/dw-run` uses it only on an explicit request — never by default.
+- **Red-capable feedback contract in `dw-debug-protocol`.** Reproduction was
+  specified as an outcome, not a procedure. A loop must now be single,
+  deterministic, fast, agent-runnable, and **proven red now** — "it should fail"
+  does not count — before any theorizing, with a repertoire of loop types and a
+  HITL template for when the loop needs credentials, hardware, or a human action.
+  `/dw-bugfix` records the loop command before and after the fix. Trivial bugs stay
+  exempt; the exemption ends when a first fix fails or the bug spans layers.
+- **Seam dependency categories and Design It Twice** in
+  `dw-simplification/references/deep-modules.md`. Classifying what a seam isolates
+  (in-process, local-substitutable, remote owned, true external) derives the test
+  strategy instead of reflexively mocking or running everything; interface findings
+  require three-plus proposals under distinct constraints before one is recommended.
+  Loaded from `/dw-refactor` only for interface/seam findings, so simple refactors
+  stay cheap.
+- **`AGENTS.md` and `CLAUDE.md`** at the repo root. A project whose product is
+  agent instructions had none for maintaining itself; the invariants existed only
+  as tests that fail after the mistake.
+
+### Fixed
+
+- **`git restore .` bypassed the git guardrails entirely.** `git checkout .` was
+  blocked while `git restore .`, `git restore -- .`, `git restore --staged
+  --worktree .` and `git restore --source=<ref> .` — which discard exactly the same
+  uncommitted work — passed through. The hook had **no test at all**, which is why
+  the hole survived. It now has one that invokes the script for real over stdin,
+  including a case that runs it from a directory whose name contains a space.
+- **`Depends on:` was parsed by the wave executor but existed in no template.**
+  `/dw-plan` told each task to declare its dependencies and
+  `dw-execute-phase/references/wave-coordination.md` built the parallel graph by
+  topological sort from that field — while `tasks-template.md` had no column for it
+  and `task-template.md` no field. The graph rested on data nothing produced. The
+  field now has a home in both, and `wave-coordination.md` uses the `1.0` task IDs
+  the pipeline actually writes instead of the `01` form its example carried.
+- **`/dw-brainstorm --research` wrote outside the repo.** Reports went to
+  `~/Documents/<Topic>_Research_<date>/`, so `/dw-plan` and `/dw-intel` could not
+  consume research the pipeline itself produced. They now land under the active
+  spec, or under `.dw/spec/research/` when standalone.
+- **The marketplace manifest had no description**, which `claude plugin validate`
+  warns about and `npm run validate` did not catch. The field was added to the
+  generator in `build-plugin.js`, not only to the checked-in JSON, so it survives
+  the next `npm run build:plugin`.
+- **The PT `/dw-refactor` searched for a section that did not exist.** It told the
+  agent to locate `Modo: refactor-audit (catalogo de code smells + deep-modules)`
+  while the heading in `dw-brainstorm` reads `catálogo`, accented. The lookup never
+  matched; the EN pair matches exactly and always worked. Surfaced by the
+  accentuation pass below.
+
+### Changed
+
+- **24 PT-BR scaffold files were written with no diacritics at all** ("Voce e a
+  entrada", "secao", "nao") while the other half of the scaffold was correctly
+  accented, making it impossible to tell a new mistake from old debt. All 24 are
+  now accented. Diacritics only, verified mechanically: both sides normalized
+  (Unicode NFKD, combining marks dropped) and compared byte for byte, so any
+  content change would have failed the check. Literal strings the commands search
+  for, code blocks, flags, paths, and English technical terms were left untouched.
+
 ## [2.0.0] — 2026-08-02
 
 First release after a full security audit of the compose recipes. Two options were

package/README.md

@@ -42,17 +42,18 @@ Exportable skills (no `.dw/` pipeline required): `dw-minimalism`, `dw-search-fir
 
 ## Commands
 
-dev-workflow v2.0.0 ships **38 commands** organized into four tiers. Most users only invoke Tier 1 + Tier 2.
+dev-workflow v2.2.0 ships **41 commands** organized into four tiers. Most users only invoke Tier 1 + Tier 2.
 
-### Tier 1 — Gateway (3)
+### Tier 1 — Gateway (4)
 
 | Command | When |
 |---------|------|
 | **`/dw-autopilot "wish"`** | Default entry point in two invocations. First run completes PRD → TechSpec → Tasks and stops. Second run resumes from state, executes `/dw-goal --from-autopilot <slug>` for Run → Review → QA/Fix → Review, then Security Gate → Commit → PR. |
 | **`/dw-bugfix "description"`** | A bug report or pasted error. Triages bug-vs-feature-vs-scope, surgical fix or routes to a PRD. |
+| **`/dw-triage [item]`** | An external bug report, feature request, or PR. Checks whether it already exists and whether it was rejected before, verifies the claim, then routes to `/dw-bugfix`, `/dw-plan prd`, or `/dw-brainstorm --mode=grill`. Local-first in `.dw/triage/`; works with no network and no `gh`. |
 | **`/dw-help [keyword]`** | Discover commands. Pass a keyword for shortcuts; `--advanced` reveals internal commands. |
 
-### Tier 2 — Pipeline granular (10)
+### Tier 2 — Pipeline granular (11)
 
 Use these when you want step-by-step control instead of `/dw-autopilot`.
 
@@ -62,24 +63,27 @@ Use these when you want step-by-step control instead of `/dw-autopilot`.
 | **`/dw-brainstorm "idea"`** | Refine a concrete idea before PRD. Flags: `--onepager` (durable artifact), `--council` (multi-advisor debate), `--research` (multi-source cited research). |
 | **`/dw-plan "feature"`** | PRD → TechSpec → Tasks sequentially with checkpoints. Stages: `prd`, `techspec`, `tasks`. Mandatory clarification questions, source-grounding, constitution gate, final consistency check. |
 | **`/dw-run [task-id]`** | Execute tasks. Default: all pending in dependency order with wave-based parallel dispatch. Single-task: pass an ID. `--resume` continues an interrupted plan. |
-| **`/dw-review`** | Level 2 (PRD coverage mapping) + Level 3 (code quality). Hard gates on dw-verify PASS, secure-audit, constitution violations. Flags: `--coverage-only`, `--code-only`, `--bugfix <slug>` (review a bugfix at `.dw/bugfixes/<slug>/`). |
+| **`/dw-review`** | Level 2 (PRD coverage mapping) + Level 3 (code quality). Hard gates on dw-verify PASS, secure-audit, constitution violations. Flags: `--coverage-only`, `--code-only`, `--bugfix <slug>` (review a bugfix at `.dw/bugfixes/<slug>/`), `--since <ref>` (ad-hoc review from a verified comparison point). |
 | **`/dw-qa`** | Mode-aware QA. Auto-detects UI vs API. Flags: `--fix` (iterative QA + fix-retest loop), `--api`, `--ai` (AI eval against reference dataset), `--uat` (human-in-the-loop walkthrough), `--bugfix <slug>` (QA a bugfix). |
 | **`/dw-pause`** | Consolidate the current session's mental state into `.dw/STATE.md` (Decisions, Blockers, Todos, Deferred, Lessons, Open Loops). Used before long breaks or context-window compactions. |
 | **`/dw-resume`** | Read `.dw/STATE.md`, present a TLDR of where work left off, and suggest the next `dw-*` command. Never auto-executes. |
+| **`/dw-report [--every <N>m]`** | Timestamped progress loop while long work runs: what is done (with evidence), what is being done (with measurable progress), what is left — every 10 minutes by default, appended to `.dw/reports/YYYY-MM-DD.md`. Silent while blocked, final report + auto-disarm when the work ends. `now`, `status`, `stop`. Auto-armed by `/dw-run`, `/dw-autopilot`, and the CLI runners; `DW_REPORT_AUTO=off` opts out, `DW_REPORT_BELL` hooks a local sound. |
 | **`/dw-commit`** | Atomic Conventional Commits for pending changes. Applies `dw-git-discipline` (one intent per commit, lint+tests+build green before). |
 | **`/dw-generate-pr [target]`** | Push the branch, draft a PR body with summary + test plan, open the browser. Hard gates: dw-verify PASS + secure-audit. |
 
-### Tier 3 — Specialty (12)
+### Tier 3 — Specialty (14)
 
 | Command | What |
 |---------|------|
 | **`/dw-analyze-project`** | Scans the repo, writes `.dw/rules/` (per-module conventions, anti-patterns, naming). Step 8 offers `.dw/constitution.md`; Step 9 writes `.dw/rules/concerns.md`; Step 10 can synthesize a frontend `DESIGN.md` from existing tokens. Run once per project; refresh after major refactors. |
 | **`/dw-redesign-ui "target"`** | Audits a frontend page, runs the `dw-ui-discipline` 4-question grounding, proposes 2-3 design directions, ships the redesign. WCAG 2.2 AA accessibility floor is non-negotiable; UI diffs can also run the deterministic impeccable slop detector. |
+| **`/dw-open-design "brief"`** | Generates, iterates, or refactors headless Open Design HTML prototypes through the `od` CLI. Refines the brief before dispatch, runs with an explicit `--agent codex\|claude`, captures JSONL audit logs, and stops for a dual ≥9 visual gate. `--refactor` works from a live URL or from screenshots. |
 | **`/dw-refactor "target"`** | Audits a target for refactor opportunities using Fowler smells, `dw-simplification`, deep-modules analysis, and behavior-preserving test gates. This is the explicit route for code-health and tech-debt work. |
 | **`/dw-functional-doc`** | Maps screens + user flows into a functional doc, validated end-to-end with Playwright. Uses the WSL-resilient browser resolver and can capture guided functional video evidence. |
 | **`/dw-context-budget`** | Audits context overhead from commands, skills, agents, instruction files, and MCPs. |
 | **`/dw-harness-audit`** | Deterministic health scorecard for the dev-workflow install, agents, wrappers, MCPs, and gates. |
 | **`/dw-skill-health`** | Audits installed skills and agents for bloat, duplication, and missing references. |
+| **`/dw-worktree <list\|create\|clean\|merge>`** | Lifecycle of delegation worktrees (`../<project>-<slug>`): `create` runs install/build prep so a delegate never works blind; `list` gives every worktree a verdict (`REMOVABLE`, `KEEP:unmerged`, `KEEP:dirty`, `KEEP:in-use`); `clean` removes only proven-merged-and-clean ones (dry-run by default, `--apply` to execute); `merge` does the safe order from the main checkout (ff-only → remove → branch delete → prune). Never `--force`. Backed by `.dw/scripts/lib/worktree-gc.mjs`; auto-used by the CLI runners, `/dw-pause`, and `/dw-harness-audit`. |
 | **`/dw-learn`** | Synthesizes durable decisions (confidence-tagged), bugfixes, deviations, and git history into atomic confidence-weighted **instincts** you approve at `.dw/memory/instincts/`; can propose constitution principles. On-demand and human-in-the-loop — **no always-on observer**. |
 | **`/dw-new-project`** | Bootstrap a new project from an empty or docs-first directory while preserving existing documentation and prototypes. Stack interview includes Next.js + NestJS, Postgres, pg-boss, Mailpit, dev topology, and wraps official `create-*` tools before composing dev infrastructure, `.env`, scripts, CI, and `.dw/rules/`. |
 | **`/dw-dockerize`** | Reads existing project, detects stack + runtime deps, proposes Dockerfile + docker-compose for dev/prod with explicit trade-offs (Conservative/Balanced/Bold). |
@@ -224,6 +228,7 @@ your-project/
 │   ├── spec/              # PRD directories — each contains tasks-validation.md
 │   ├── bugfixes/          # Persistent bugfix records: NNN-<slug>/{TASK.md, SUMMARY.md, fix-report.md} + review/, QA/
 │   ├── goals/             # Durable goal state used by /dw-goal and /dw-autopilot
+│   ├── reports/           # Progress-report loop (/dw-report): daily YYYY-MM-DD.md logs + .active.json, machine-local (gitignored)
 │   ├── secure-audit/      # Security Gate summaries and per-layer reports
 │   ├── subtasks/          # Local ephemeral subagent input packets and handoffs (pending/archive ignored by Git)
 │   └── STATE.md           # Session state: Decisions, Blockers, Todos, Open Loops, Deferred Ideas, Lessons, Preferences (managed by /dw-pause + /dw-resume)

package/lib/build-plugin.js

@@ -22,6 +22,8 @@ const { readSkillRegistry } = require('./skill-registry');
 
 const REPO_ROOT = path.join(__dirname, '..');
 const PLUGIN_DIR = path.join(REPO_ROOT, '.claude-plugin');
+const MARKETPLACE_DESCRIPTION =
+  'À-la-carte dev-workflow skills for focused agent work: minimalism, search-first research, verification, security review, and code quality.';
 
 function buildManifests() {
   const registry = readSkillRegistry();
@@ -46,6 +48,7 @@ function buildManifests() {
 
   const marketplace = {
     name: 'brunosps00-dev-workflow',
+    description: MARKETPLACE_DESCRIPTION,
     owner: author,
     plugins: [
       {
@@ -72,7 +75,7 @@ function run() {
   for (const name of exportable) console.log(`  - ${name}`);
 }
 
-module.exports = { buildManifests, run };
+module.exports = { buildManifests, run, MARKETPLACE_DESCRIPTION };
 
 if (require.main === module) {
   run();

package/lib/constants.js

@@ -29,14 +29,17 @@ const COMMANDS = {
     { name: 'dw-qa', description: 'Trigger when user wants to validate behavior beyond unit tests. Mode-aware (UI / API / --ai / --uat). --fix enters the iterative QA + fix-retest loop. --bugfix <slug> targets a .dw/bugfixes/ entry.' },
     { name: 'dw-redesign-ui', description: 'Audits a frontend page, proposes design directions you choose from, then ships the redesign.' },
     { name: 'dw-refactor', description: 'Audits a target for refactor opportunities using the refactor-audit protocol, Fowler smells, deep-modules analysis, and behavior-preserving test gates.' },
+    { name: 'dw-report', description: 'Trigger when user asks for periodic progress reports ("report every 10 minutes", "keep me posted while this runs"). Timestamped done / doing / remaining report at a fixed cadence (default 10m, --every <N>m), appended to .dw/reports/YYYY-MM-DD.md; silent while blocked, final report + auto-disarm when the work ends. Auto-armed by dw-run, dw-autopilot, and the dw-cli-run adapters.' },
     { name: 'dw-resume', description: 'Trigger when user says "resume work", "where did we stop?", or starts a session in a project with an existing .dw/STATE.md. Reads STATE.md, presents a TLDR, and suggests the next dw-* command.' },
-    { name: 'dw-review', description: 'Trigger when user asks to review code, check quality, or verify PR readiness. Default runs L2 (PRD coverage) + L3 (code quality). Flags --coverage-only / --code-only / --bugfix <slug>.' },
+    { name: 'dw-review', description: 'Trigger when user asks to review code, check quality, or verify PR readiness. Default runs L2 (PRD coverage) + L3 (code quality). Flags --coverage-only / --code-only / --bugfix <slug> / --since <ref>.' },
     { name: 'dw-run', description: 'Trigger when user wants to execute tasks. Default runs all pending in dependency order; \'run <task-id>\' runs one; \'run --resume\' continues an interrupted plan.' },
     { name: 'dw-secure-audit', description: 'Security Gate: OWASP + Semgrep SAST (diff) + gitleaks secrets + Trivy SCA/IaC + lockfile + supply-chain + outdated. Rigoroso: secrets/CRITICAL/HIGH block. Auto-invoked by /dw-review and /dw-generate-pr, explicit phase in /dw-autopilot, and runnable standalone.' },
     { name: 'dw-skill-health', description: 'Audits installed skills and agents for bloat, duplication, missing references, and stale or unused modules.' },
     { name: 'dw-subtask-start', userInvoked: true, description: 'Creates a minimal input packet for a subagent without injecting the parent transcript.' },
     { name: 'dw-subtask-complete', userInvoked: true, description: 'Records a structured subagent handoff with result, files, decisions, risks, verification, and blockers.' },
     { name: 'dw-subtask-resume', userInvoked: true, description: 'Consumes pending subagent handoffs, summarizes them for the parent, and archives the local packets.' },
+    { name: 'dw-triage', description: 'Local-first intake for external bug reports, feature requests, and PRs. Persists .dw/triage/ state, checks redundancy and prior rejections, verifies claims, then routes to /dw-bugfix, /dw-plan prd, /dw-brainstorm --mode=grill, or no work.' },
+    { name: 'dw-worktree', description: 'Worktree lifecycle for delegated work: create prepared (../<project>-<slug> + install/build prep), list with verdicts (REMOVABLE / KEEP:unmerged / KEEP:dirty / KEEP:in-use), clean only what is proven merged and clean (dry-run by default), merge in the safe ff-only order and remove in the same turn. Never --force. Backed by .dw/scripts/lib/worktree-gc.mjs; used by the dw-*-run adapters, /dw-pause, and /dw-harness-audit.' },
     { name: 'dw-update', description: 'Updates dev-workflow to the latest npm release in-place, with a snapshot you can roll back to.' },
   ],
   'pt-br': [
@@ -69,14 +72,17 @@ const COMMANDS = {
     { name: 'dw-qa', description: 'Trigger quando usuario quer validar comportamento alem de unit tests. Mode-aware (UI / API / --ai / --uat). --fix entra no loop iterativo QA + fix-retest. --bugfix <slug> aponta para uma entrada em .dw/bugfixes/.' },
     { name: 'dw-redesign-ui', description: 'Audita uma pagina frontend, propoe direcoes de design que voce escolhe, e entrega o redesign.' },
     { name: 'dw-refactor', description: 'Audita um target por oportunidades de refactor usando o protocolo refactor-audit, smells Fowler, deep-modules e gates de teste preservando comportamento.' },
+    { name: 'dw-report', description: 'Trigger quando usuário pede report periódico de progresso ("report de 10 em 10 minutos", "me mantém informado enquanto isso roda"). Report carimbado com data/hora de feito / fazendo / falta em cadência fixa (default 10m, --every <N>m), anexado em .dw/reports/YYYY-MM-DD.md; silencioso enquanto bloqueado, report final + auto-desarme quando o trabalho termina. Auto-armado por dw-run, dw-autopilot e pelos adapters dw-cli-run.' },
     { name: 'dw-resume', description: 'Trigger quando usuario diz "retoma", "onde paramos?" ou comeca sessao num projeto com .dw/STATE.md existente. Le STATE.md, apresenta TLDR e sugere proximo comando dw-*.' },
-    { name: 'dw-review', description: 'Trigger quando usuario pede pra revisar codigo, checar qualidade ou validar prontidao pra PR. Default roda L2 (cobertura PRD) + L3 (qualidade). Flags --coverage-only / --code-only / --bugfix <slug>.' },
+    { name: 'dw-review', description: 'Trigger quando usuário pede pra revisar código, checar qualidade ou validar prontidão pra PR. Default roda L2 (cobertura PRD) + L3 (qualidade). Flags --coverage-only / --code-only / --bugfix <slug> / --since <ref>.' },
     { name: 'dw-run', description: 'Trigger quando usuario quer executar tasks. Default roda todas pendentes em ordem de dependencia; \'run <task-id>\' roda uma; \'run --resume\' continua plan interrompido.' },
     { name: 'dw-secure-audit', description: 'Security Gate: OWASP + Semgrep SAST (diff) + gitleaks secrets + Trivy SCA/IaC + lockfile + supply-chain + outdated. Rigoroso: secrets/CRITICAL/HIGH bloqueiam. Auto-invocado por /dw-review e /dw-generate-pr, fase explicita no /dw-autopilot, e executavel standalone.' },
     { name: 'dw-skill-health', description: 'Audita skills e agentes instalados por bloat, duplicacao, referencias quebradas e modulos sem uso.' },
     { name: 'dw-subtask-start', userInvoked: true, description: 'Cria um input packet minimo para subagente sem injetar transcript bruto do parent.' },
     { name: 'dw-subtask-complete', userInvoked: true, description: 'Registra handoff estruturado do subagente com resultado, arquivos, decisoes, riscos, verificacao e bloqueios.' },
     { name: 'dw-subtask-resume', userInvoked: true, description: 'Consome handoffs pendentes de subagentes, resume para o parent e arquiva os pacotes locais.' },
+    { name: 'dw-triage', description: 'Intake local-first para bug reports, feature requests e PRs externos. Persiste estado em .dw/triage/, checa redundância e rejeições anteriores, verifica alegações, e então roteia para /dw-bugfix, /dw-plan prd, /dw-brainstorm --mode=grill, ou nenhum trabalho.' },
+    { name: 'dw-worktree', description: 'Ciclo de vida de worktrees de delegação: cria preparada (../<projeto>-<slug> + prep de install/build), lista com vereditos (REMOVABLE / KEEP:unmerged / KEEP:dirty / KEEP:in-use), limpa só o que está provadamente mergeado e limpo (dry-run por default), mergeia na ordem segura ff-only e remove no mesmo turno. Nunca --force. Apoiado em .dw/scripts/lib/worktree-gc.mjs; usado pelos adapters dw-*-run, /dw-pause e /dw-harness-audit.' },
     { name: 'dw-update', description: 'Atualiza o dev-workflow para o release mais recente no npm, com snapshot para rollback.' },
   ],
 };

package/lib/init.js

@@ -283,6 +283,32 @@ async function run({ force = false, lang = null, mode = 'init', profile = null,
     touchedFiles.push(metricsGitignore);
   }
 
+  // 5.25b. Ensure .dw/reports/ + .gitignore (progress-report loop; the daily logs and
+  // the .active.json loop state are machine-local so they are gitignored, while other
+  // reports such as context-budget.md stay tracked). Created if missing on init and update.
+  {
+    const reportsDir = path.join(projectRoot, '.dw', 'reports');
+    ensureDir(reportsDir);
+    const reportsGitignore = path.join(reportsDir, '.gitignore');
+    const rStatus = writeFile(reportsGitignore, '????-??-??.md\n.active.json\n', false);
+    if (rStatus === 'created') totalCreated++;
+    else totalSkipped++;
+    touchedFiles.push(reportsGitignore);
+  }
+
+  // 5.25c. Ensure .dw/cli-run/ + .gitignore (durable audit logs, session sidecars and
+  // last-message captures of the dw-*-run adapters are machine-local; committing them
+  // bloats every worktree checkout). Created if missing on init and update.
+  {
+    const cliRunDir = path.join(projectRoot, '.dw', 'cli-run');
+    ensureDir(cliRunDir);
+    const cliRunGitignore = path.join(cliRunDir, '.gitignore');
+    const cStatus = writeFile(cliRunGitignore, '*\n!.gitignore\n', false);
+    if (cStatus === 'created') totalCreated++;
+    else totalSkipped++;
+    touchedFiles.push(cliRunGitignore);
+  }
+
   // 5.26. Ensure .dw/memory/instincts/ (durable learnings promoted by /dw-learn;
   // format in the dw-memory skill's references/instincts.md). Init only; preserved on update.
   if (!isUpdate) {

package/lib/validate.js

@@ -23,8 +23,10 @@ function run() {
 
   // Plugin manifest drift check.
   const { plugin, marketplace } = buildManifests();
+  checkMarketplaceDescription(marketplace, issues);
   checkManifestDrift('.claude-plugin/plugin.json', plugin, issues);
   checkManifestDrift('.claude-plugin/marketplace.json', marketplace, issues);
+  checkMarketplaceFileDescription('.claude-plugin/marketplace.json', issues);
 
   console.log('dev-workflow validate\n');
   if (warnings.length) {
@@ -55,6 +57,25 @@ function checkManifestDrift(relPath, expected, issues) {
   }
 }
 
+function checkMarketplaceDescription(marketplace, issues) {
+  if (!marketplace || typeof marketplace.description !== 'string' || !marketplace.description.trim()) {
+    issues.push('Generated marketplace manifest must include a root-level description.');
+  }
+}
+
+function checkMarketplaceFileDescription(relPath, issues) {
+  const file = path.join(__dirname, '..', relPath);
+  if (!fs.existsSync(file)) return;
+  try {
+    const manifest = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    if (typeof manifest.description !== 'string' || !manifest.description.trim()) {
+      issues.push(`${relPath} must include a root-level description.`);
+    }
+  } catch {
+    issues.push(`${relPath} is not valid JSON.`);
+  }
+}
+
 module.exports = { run };
 
 if (require.main === module) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brunosps00/dev-workflow",
-  "version": "2.0.0",
+  "version": "2.2.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/agent-instructions.md

@@ -37,6 +37,8 @@ Before picking a command from the Trigger Map, gauge the change's actual scope.
 | "Run this as a goal" / "durable goal" / "long-running objective" | `/dw-goal "<objective>"` |
 | "Continue where I left off" | `/dw-run --resume` |
 | "Pause work" / "End the session" / "Save where we are" | `/dw-pause` |
+| "Report every N minutes" / "Keep me posted while this runs" / "Give me status reports" | `/dw-report [--every <N>m]` |
+| "Create a worktree for X" / "Clean up the worktrees" / "Merge worktree X" / "How many worktrees are left?" | `/dw-worktree create <slug>` / `/dw-worktree clean --apply` / `/dw-worktree merge <slug>` / `/dw-worktree list` |
 | "Resume" / "Where did we stop?" / "Pick up where we left off" | `/dw-resume` |
 | "QA this feature" / "Run the test plan" | `/dw-qa` |
 | "Fix the QA bugs" | `/dw-qa --fix` |

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

@@ -143,6 +143,8 @@ After approval:
 
 ### Step 8: Durable Execution Goal
 
+First arm the progress loop: invoke `/dw-report` (auto-arm contract — idempotent, skipped when `DW_REPORT_AUTO=off`). It reports done / doing / remaining every 10 minutes through the goal, the Security Gate, commit, and PR, and disarms itself with a final report at the PR gate.
+
 When `autopilot-state.json status=plan_complete`, formally invoke:
 
 ```text

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

@@ -181,7 +181,7 @@ At the end, always leave the user in one of these situations:
 - With better questions to decide
 - With a next workspace command to follow
 - With the one-pager at `.dw/spec/ideas/<slug>.md` (if **onepager** mode fired)
-- With the research report at `~/Documents/<Topic>_Research_<date>/` (if **research** mode fired)
+- With the research report at `.dw/spec/<prd-slug>/research/<topic-slug>-<YYYYMMDD>/research.md` when a PRD is active, `.dw/spec/ideas/<idea-slug>-research-<YYYYMMDD>/research.md` when an idea one-pager is active, or `.dw/spec/research/<topic-slug>-<YYYYMMDD>/research.md` for standalone research (if **research** mode fired)
 - With the refactor plan at `<target>/refactor-plan.md` (if **refactor-audit** mode fired)
 - With canonical glossary entries in `.dw/domain/**` and an aligned idea one-pager (if **grill** ran with authorization)
 - With a runnable throwaway prototype + verdict template (if **prototype** mode fired)
@@ -237,7 +237,7 @@ Complementary skill **`dw-source-grounding`**: **ALWAYS** — apply Detect → F
 
 ### Output
 
-Saved to `~/Documents/<Topic>_Research_<YYYYMMDD>/`. Mandatory sections:
+Save `research.md` inside the repo: `.dw/spec/<prd-slug>/research/<topic-slug>-<YYYYMMDD>/research.md` when a PRD is active, `.dw/spec/ideas/<idea-slug>-research-<YYYYMMDD>/research.md` when an idea one-pager is active, or `.dw/spec/research/<topic-slug>-<YYYYMMDD>/research.md` for standalone research. Mandatory sections:
 1. Executive Summary (200-400 words)
 2. Introduction (scope, methodology, assumptions)
 3. Main Analysis (4-8 findings, 600-2000 words each, all cited)
@@ -364,9 +364,12 @@ When these signals appear during auto-dispatch, **recommend** Grill in one line
 
 ### The session (after authorization)
 
-1. **Build the decision tree first.** Before the first question, inspect project facts — current PRDs/TechSpecs,
-   `.dw/rules/`, `.dw/intel/` (via `/dw-intel`), `.dw/constitution.md`, `.dw/domain/**`, and recent git activity —
-   and build a decision tree **ordered by dependencies** (never ask a downstream decision before its blocker).
+1. **Resume or build the decision tree first.** Before the first question, read the active one-pager for an
+   existing **Decision Map**. If present, resume from its `Depends on:` graph, `State` values, explicit
+   **Frontier**, and `Decision Fog`; do not re-ask nodes already `resolved`. If no map exists, inspect project
+   facts — current PRDs/TechSpecs, `.dw/rules/`, `.dw/intel/` (via `/dw-intel`), `.dw/constitution.md`,
+   `.dw/domain/**`, and recent git activity — and build a decision tree **ordered by dependencies** (never ask a
+   downstream decision before its blocker).
 2. **Ask exactly one unresolved decision per interaction and wait.** Each question includes: evidence when
    available (with source), the recommended answer, a short rationale, and a meaningful alternative/trade-off.
    Follow `dw-grilling` (`references/interview-loop.md`, `references/decision-tree.md`).
@@ -403,9 +406,10 @@ reads and links `.dw/domain/**` and must preserve it, never regenerate it.
 
 ### Aligned handoff — the idea one-pager (schema `1.1`)
 
-Grill extends `.dw/spec/ideas/<slug>.md` to schema `1.1`, adding: **Resolved Decisions** (each with the recommended
-answer, the user's choice, and the alternative rejected), **Evidence** (facts discovered with sources),
-**Canonical Vocabulary** (links into `.dw/domain/**`), **Remaining Decisions**, and **Alignment State**.
+Grill extends `.dw/spec/ideas/<slug>.md` to schema `1.1`, adding: **Decision Map** (nodes, `Depends on:`, `State`,
+explicit **Frontier**, and `Decision Fog` for unclear future nodes), **Resolved Decisions** (each with the
+recommended answer, the user's choice, and the alternative rejected), **Evidence** (facts discovered with
+sources), **Canonical Vocabulary** (links into `.dw/domain/**`), **Remaining Decisions**, and **Alignment State**.
 
 Set `status: aligned` **only when all** of these hold: every dependency branch is resolved, glossary/code
 contradictions are closed, no blocking open decision remains, AND the user **explicitly confirms** shared

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

@@ -38,7 +38,7 @@
 
     When available in the project at `./.agents/skills/`, use these skills as contextual support without replacing this command:
 
-    - `dw-debug-protocol`: **ALWAYS** — runs the bug through the six-step triage (Reproduce → Localize → Reduce → Fix Root Cause → Guard → Verify End-to-End). Stop-the-line discipline; root-cause over symptom; regression test committed in the same atomic commit. Non-reproducible bugs follow the instrument-first sub-protocol — no guess fixes without explicit acknowledgement.
+    - `dw-debug-protocol`: **ALWAYS** — runs the bug through the six-step triage (Reproduce → Localize → Reduce → Fix Root Cause → Guard → Verify End-to-End). Stop-the-line discipline; root-cause over symptom; regression test committed in the same atomic commit. For non-trivial bugs, or after a first fix fails, Step 1 must establish a red-capable feedback loop before theorizing. Non-reproducible bugs follow the instrument-first sub-protocol — no guess fixes without explicit acknowledgement.
     - `dw-verify`: **ALWAYS** — in Direct mode, invoked before committing the fix. The VERIFICATION REPORT must show the original bug symptom no longer reproduces (not just that tests pass).
     - `vercel-react-best-practices`: use when the bug affects React/Next.js and there is suspicion of render, hydration, fetching, waterfall, bundle, or re-render issues
     - `dw-testing-discipline`: use when the fix requires a reproducible E2E/retest flow in a web app — `references/playwright-recipes.md` for recipes, core rules + 6 agent guardrails for any test the fix adds, flaky-discipline if the bug surfaces intermittently.
@@ -214,6 +214,7 @@
     - Stack traces
     - Recently modified files
     - If the bug is UI-related or depends on browser flow, supplement collection with `dw-testing-discipline` (playwright-recipes + three-workflow-patterns to pick the right verification mode)
+    - For non-trivial bugs, or when the first fix attempt failed, build the `dw-debug-protocol` red-capable feedback loop before proposing a cause: one loop command/artifact, deterministic enough, fast, agent-runnable, and observed red. If no agent-runnable loop is possible, record attempts and ask the user for the missing artifact/access with the HITL template from `references/six-step-triage.md`.
 
     ### 3. Clarification Questions (MANDATORY - EXACTLY 3)
 
@@ -384,7 +385,7 @@
     1. Discover the next `NNN` (see File Locations section).
     2. Create `.dw/bugfixes/NNN-<slug>/` if not yet created in step 5.0.
     3. Write `TASK.md` with the triage, clarifications, root cause, and the approved plan as executed (use `.dw/templates/bugfix-template.md` as the base structure).
-    4. Write `fix-report.md` with the verbatim `dw-verify` VERIFICATION REPORT plus the before/after reproduction trace.
+    4. Write `fix-report.md` with the verbatim `dw-verify` VERIFICATION REPORT plus the before/after reproduction trace. The report MUST include `Loop command before fix` and `Loop command after fix` (or the exact HITL blocker, attempts made, and artifact/access requested when no loop was possible).
     5. Write `SUMMARY.md` using `.dw/templates/bugfix-summary-template.md`. Fill in slug, date, status `Fixed`, severity, related_concerns (from step 1.5), Symptom (verbatim), Root Cause (one sentence), Resolution (2-4 bullets), Files Touched, Verification, Related, Followups.
     6. If the fix touched a concern listed in `.dw/rules/concerns.md`, append a line to that concern's row's `Last incident` column (or add a new row under Known Bug History) — preserve hand-written entries between `<!-- preserved:start -->` markers.
     7. Report paths of all three files in chat before the commit step.
@@ -494,6 +495,7 @@
     - [ ] **Maximum 5 affected files**
     - [ ] **No migrations**
     - [ ] **Test task included (correct project framework)**
+    - [ ] **Non-trivial bug loop recorded: command before fix + command after fix, or HITL blocker with attempts + requested artifact/access**
     - [ ] Awaiting approval before executing
     - [ ] **`.dw/bugfixes/NNN-<slug>/{TASK,fix-report,SUMMARY}.md` written after verify PASS**
 

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

@@ -39,7 +39,7 @@ Because you pass `--session-id "$UUID"`, the id is **fixed and known** at dispat
 ## Input Variables
 | Variable | Description | Example |
 |----------|-------------|---------|
-| `<WORKTREE>` | dedicated git worktree (off main) | `~/code/vizzita-billing-s10` |
+| `<WORKTREE>` | dedicated git worktree (off main) — create with `/dw-worktree create <slug>` (prep included); after the gate and merge, remove in the same turn with `/dw-worktree merge <slug>` | `~/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` |

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

@@ -40,7 +40,7 @@ gone: `codex exec resume --last` from the same worktree.
 ## Input Variables
 | Variable | Description | Example |
 |----------|-------------|---------|
-| `<WORKTREE>` | dedicated git worktree (off main) | `~/code/vizzita-billing-s10` |
+| `<WORKTREE>` | dedicated git worktree (off main) — create with `/dw-worktree create <slug>` (prep included); after the gate and merge, remove in the same turn with `/dw-worktree merge <slug>` | `~/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` |

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

@@ -37,7 +37,7 @@ Fallback if the sidecar is gone: `copilot --continue -p …` from the same workt
 ## Input Variables
 | Variable | Description | Example |
 |----------|-------------|---------|
-| `<WORKTREE>` | dedicated git worktree (off main) | `~/code/vizzita-billing-s10` |
+| `<WORKTREE>` | dedicated git worktree (off main) — create with `/dw-worktree create <slug>` (prep included); after the gate and merge, remove in the same turn with `/dw-worktree merge <slug>` | `~/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` |

package/scaffold/en/commands/dw-harness-audit.md

@@ -22,7 +22,9 @@ You are the dev-workflow harness auditor.
    - Verification gates
    - Security gates
    - Context discipline
+   - Worktree hygiene
 3. For structured skill returns, inspect bundled skill `SKILL.md` files and require a `## Structured Return` contract with `Status`, `Evidence`, `Artifacts`, and `Next Step`.
+3b. For worktree hygiene, run `node .dw/scripts/lib/worktree-gc.mjs list --strict`. Exit 3 (any `REMOVABLE` or `PRUNABLE` worktree) caps the category at 3/10; cite each leftover with its size and verdict and recommend `/dw-worktree clean --apply`. `KEEP:*` entries are informational.
 4. Cite missing paths, broken references, stale managed files, and skills without a structured return.
 5. Recommend the top 3 fixes.
 

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

@@ -23,7 +23,7 @@ Use `/dw-autopilot "wish"` as the gateway for most feature work. The granular co
 | `/dw-bugfix "description"` | A bug or error report. Surgical fix or PRD route. |
 | `/dw-help [keyword]` | This screen. Pass a keyword for shortcuts. `--advanced` reveals internal commands. |
 
-## Tier 2 — Pipeline granular (10)
+## Tier 2 — Pipeline granular (11)
 
 | Command | What |
 |---------|------|
@@ -35,10 +35,11 @@ Use `/dw-autopilot "wish"` as the gateway for most feature work. The granular co
 | `/dw-qa` | Mode-aware QA (UI / API auto-detect). Flags: `--fix`, `--api`, `--ai`, `--uat`, `--bugfix <slug>`. |
 | `/dw-pause` | Save session state, decisions, blockers, todos, and open loops into `.dw/STATE.md`. |
 | `/dw-resume` | Read `.dw/STATE.md`, show a TLDR, and suggest the next `dw-*` command. |
+| `/dw-report [--every <N>m]` | Timestamped done / doing / remaining report every 10 minutes while long work runs; appended to `.dw/reports/`. `now`, `status`, `stop`. Auto-armed by `/dw-run`, `/dw-autopilot`, and the CLI runners. |
 | `/dw-commit` | Atomic Conventional Commits for pending work. |
 | `/dw-generate-pr [target]` | Push branch, draft PR body, open browser. |
 
-## Tier 3 — Specialty (12)
+## Tier 3 — Specialty (13)
 
 | Command | What |
 |---------|------|
@@ -50,6 +51,7 @@ Use `/dw-autopilot "wish"` as the gateway for most feature work. The granular co
 | `/dw-context-budget` | Audit context overhead from commands, skills, agents, instructions, and MCPs. |
 | `/dw-harness-audit` | Score dev-workflow install health: wrappers, agents, MCPs, gates. |
 | `/dw-skill-health` | Audit skills and agents for bloat, duplication, and missing references. |
+| `/dw-worktree <list\|create\|clean\|merge>` | Worktree lifecycle: create prepared, list with verdicts, clean only proven-merged (dry-run default), ff-only merge + remove in the same turn. Never `--force`. |
 | `/dw-new-project` | Interview-driven bootstrap (stack + infra + docker-compose + CI). |
 | `/dw-dockerize` | Detect stack, propose Dockerfile + docker-compose for dev/prod. |
 | `/dw-install-azure-skills` | Opt-in Azure skills + Microsoft Learn MCP setup. Interactive category selection. |
@@ -103,6 +105,7 @@ Match the keyword and suggest:
 | `run`, `execute`, `implement` | `/dw-run` |
 | `goal`, `objective`, `long-running`, `resume autopilot` | `/dw-goal` or `/dw-autopilot` if `autopilot-state.json` exists |
 | `pause`, `save state`, `end session` | `/dw-pause` |
+| `report`, `progress`, `keep me posted`, `status every` | `/dw-report [--every <N>m]` |
 | `resume`, `continue`, `where did we stop` | `/dw-resume` |
 | `review`, `quality`, `audit code` | `/dw-review` |
 | `qa`, `test plan`, `e2e` | `/dw-qa` |
@@ -121,6 +124,7 @@ Match the keyword and suggest:
 | `design.md`, `design authority`, `concerns map` | `/dw-analyze-project` (also listed as a post-update action when missing) |
 | `subagent`, `subtask`, `handoff`, `delegate` | `/dw-subtask-start` or `/dw-subtask-resume` |
 | `skills`, `skill health`, `bloat` | `/dw-skill-health` |
+| `worktree`, `worktrees`, `disk`, `merge worktree`, `clean worktrees` | `/dw-worktree list` / `create <slug>` / `clean --apply` / `merge <slug>` |
 | `analyze`, `rules`, `conventions` | `/dw-analyze-project` |
 | `constitution`, `principles` | `/dw-analyze-project` (Step 8 generates the constitution) |
 | `security opportunities`, `hardening ideas`, `improve security` | `/dw-opportunities "security"` |