0.15.0 - 2026-07-01

Release Notes

Added

• A regression harness for the auto-review Stop hook loop,
  scripts/verify-auto-review-hook-loop.sh. It drives the real hook scripts
  end-to-end in hermetic temp dirs and asserts all four contract states against
  the concrete .claude/hooks/rdm-review-on-finalize.sh — fires
  {"decision":"block",...} when an item is needs-review on the current
  branch, stays silent on an unrelated branch, stays silent under the
  stop_hook_active loop guard, and stays silent once the item is reviewed —
  plus the shipped rdm-core/src/templates/hook-review-on-finalize.sh's
  previously-untested loop-guard and reviewed-cleared cases. Auto-picked-up by
  the existing scripts/verify-*.sh CI glob.

• phase update/task update --status needs-review now warns on stderr when
  HEAD carries no committed changes worth reviewing, surfacing items that would
  otherwise be silently stranded in needs-review with nothing to review. For a
  phase, the baseline is the previous finalized phase in the same roadmap (so the
  long-lived roadmap/<slug> branch in the one-worktree-per-roadmap model is
  handled correctly): it warns when HEAD has not advanced past that phase's
  committed work. For the first phase of a roadmap and for standalone tasks, the
  baseline is the configured default_branch: it warns when HEAD has no commits
  beyond it. The transition is not blocked and the check fails open on any git
  error — this is a non-destructive data-integrity nicety, not a gate.

• rdm review restamp refreshes review_sha/review_branch on every in-scope
  needs-review item to the current source-repo HEAD and branch. Run it after
  amending or rebasing a commit while an item is still needs-review: the
  original stamp would otherwise point at a now-dangling commit and the item
  could silently drop out of rdm review pending scope (via the
  SHA-reachability fallback), suppressing the auto-review reprompt. Scope
  matches review pending exactly, and it is idempotent (items already stamped
  at the current HEAD/branch are left untouched). The Claude Stop hook, the Pi
  agent_end extension, the generated hook-review-on-finalize.sh template,
  and the shipped .claude/hooks/rdm-review-on-finalize.sh now call it
  automatically before checking review pending, so this self-heals
  transparently in the normal finalize → review loop.

• rdm worktree prune removes every worktree whose plan item is already done
  in one command. Resolves each rdm-managed worktree's item status (phase, task,
  or whole roadmap) and removes the done ones; dirty worktrees are skipped unless
  --force, --delete-branch also deletes their merged branches, and
  --dry-run reports what would be removed without changing anything. See
  docs/landing.md.

• rdm agent-config --skills now emits an rdm-land skill (CLI and MCP
  variants) that lands a reviewed item to main with linear history
  (rebase onto main, then git merge --ff-only — never a merge commit),
  re-running the CI-equivalent checks on the rebased branch first. The
  fast-forward flips the item to done via the existing post-commit hook, and
  the skill then cleans up the worktree (rdm worktree remove --delete-branch,
  or rdm worktree prune for batch cleanup). On rebase conflict or failing
  checks it aborts cleanly and escalates per docs/escalation-protocol.md
  instead of force-merging. Landing runs only on explicit invocation (or
  autopilot's opt-in --land); it never auto-lands. See
  docs/landing.md.

• rdm-autopilot agent skill (shipped by rdm agent-config --skills, in both
  CLI and MCP variants). It drives one named roadmap from not-started to
  reviewed unattended: each iteration asks rdm next for the next actionable
  phase, estimates it (rdm-estimate) if needed, dispatches it on its model
  tier through rdm-dispatch-phase (plan gate, implementation, rdm-review),
  interprets the reviewed/rework/escalated outcome, and advances —
  parking a phase blocked when its rework budget is exhausted so the loop
  steps past it. Decisions and blockers are batched, not raised mid-run
  (review them with rdm review blocked), and the run is bounded by a global
  step budget. Opt-in --land (default OFF — main is never touched without
  it) and bounded --plan-only / --max-phases dry-run modes. See
  docs/autonomous-loop.md.

Fixed

• rdm worktree prune --delete-branch now reports partial success when a done
  item's worktree is removed but its branch is retained because the branch is not
  merged into HEAD (and --force was not passed). Previously the whole operation
  was reported as failed even though the worktree removal succeeded, so the
  removed/failed counts misled and the orphaned branch could not be
  re-cleaned by a later prune. There is now a distinct removed-branch-kept
  action with a per-result reason, a top-level branch_kept count in
  --format json, and a matching N branch kept figure and removed, branch kept (…) note in the text summary.
• rdm worktree prune now reports a worktree that became dirty between the
  initial scan and its removal as skipped-dirty rather than failed.
• rdm worktree add/list/remove now work when the project's canonical repo
  is bare (no working tree of its own) — whether invoked from a linked
  worktree of the bare repo or from inside the bare directory itself. Previously
  every subcommand failed with "not inside a git repository". Sibling worktrees
  are placed under <parent>/<repo-name>__worktrees/, with any .git/.bare
  suffix stripped from the anchor name so the layout matches the normal-repo
  case.
• rdm worktree commands run against a working directory that does not exist (or
  is not a directory) now report an actionable "directory does not exist" error
  instead of the misleading "git is not installed".

Changed

• The rdm-do, rdm-review, and rdm-dispatch-phase skills emitted by rdm agent-config (CLI and MCP variants) now describe the split Done: line as a
  single deferred two-stage protocol. The finalize step says the Done: line is
  withheld YET because rdm-review adds it on a passing review, and the review
  gate's git commit --amend step says it is completing that deferred
  directive — so neither stage reads as contradicting the other. This stops
  auto-mode agent permission classifiers from denying the review-time amend as a
  violation of the finalize-time "no Done: line" instruction.
• The rdm-review skill emitted by rdm agent-config now runs the full
  find → verify → filter → report → act → gate pipeline: an adaptive review
  fleet (base AC-compliance + correctness agents, plus conditional agents gated
  on what the diff touches), a per-finding adversarial refute/verify pass where
  the agent that finds an issue is never the one that confirms it, and a
  confidence filter that drops refuted or low-confidence findings before
  anything is fixed or filed. This brings the generated skill to parity with the
  in-repo dogfooding rdm-review skill (previously it shipped an older
  fixed-two-agent find → report → act flow). Both the CLI and MCP flavors are
  updated.
• The rdm-review skill emitted by rdm agent-config now escalates a review to
  a BLOCKED verdict when any surviving finding is blocking, matching the
  in-repo skill. It adds an explicit severity scale, a strict verdict-order
  (BLOCKED → FAIL → PASS WITH CONCERNS → PASS), and a gate that routes a BLOCKED
  phase to blocked and a BLOCKED task to in-progress (tasks have no blocked
  status) instead of silently downgrading blockers to "pass with concerns". Both
  the CLI and MCP flavors are updated.

Install rdm-cli 0.15.0

Install prebuilt binaries via shell script

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/edpaget/rdm/releases/download/v0.15.0/rdm-cli-installer.sh | sh

Install prebuilt binaries via Homebrew

brew install edpaget/rdm/rdm-cli

Install prebuilt binaries into your npm project

npm install @edpaget/rdm@0.15.0

Download rdm-cli 0.15.0

File	Platform	Checksum
rdm-cli-aarch64-apple-darwin.tar.xz	Apple Silicon macOS	checksum
rdm-cli-x86_64-apple-darwin.tar.xz	Intel macOS	checksum
rdm-cli-aarch64-unknown-linux-gnu.tar.xz	ARM64 Linux	checksum
rdm-cli-x86_64-unknown-linux-gnu.tar.xz	x64 Linux	checksum

---

Verifying Signatures

All release artifacts are signed with Sigstore cosign using keyless signing. To verify an artifact:

cosign verify-blob <artifact> \
  --bundle <artifact>.bundle \
  --certificate-identity-regexp "https://github\.com/edpaget/rdm/\.github/workflows/sign-release\.yml@refs/tags/.*" \
  --certificate-oidc-issuer "https://token.actions.githubusercontent.com"