fix(premerge): scope 4c's verify review to the polish, not the whole stack

.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
       "name": "uberdev",
       "source": "./plugins/uberdev",
       "description": "GitHub workflow commands + full Superpowers skill suite (brainstorm with visual companion, write-plan, execute-plan, subagent-driven-dev wave-based parallel execution, finish-branch, systematic-debugging, TDD, worktrees, parallel-agents, verification, code-review pair, writing-skills, using-uberdev primer) and PR review agents. /solve and /turbo dispatch autonomous agents via a platform-aware dispatch backend (Workflow-native solver fleets by default, with detached wezterm / background transports opt-in — cross-platform on macOS, Linux, WSL2, native Windows); /issue creates well-investigated, deduped issues.",
-      "version": "0.56.1",
+      "version": "0.56.2",
       "category": "workflow",
       "tags": [
         "github",

CHANGELOG.md

@@ -4,6 +4,79 @@ All notable changes to UberDev are documented here.
 
 The format is based on [Keep a Changelog 1.1.0](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.56.2] — 2026-08-24
+
+### Fixed — `/premerge` 4c reviewed the whole stack, so a resampled blocker reverted a correct refactor (#795)
+
+`### 4c — VERIFY` dispatched `Skill("code-review", "<level> <PREMERGE_PR>")` while
+its own prose claimed the call was *"scoped to the refactor"*. `<PREMERGE_PR>` is
+the stack PR, so nothing was scoped: the verify step re-reviewed the entire stack
+and the built-in reviewer treated that whole diff as its scope.
+
+4c is not a discovery pass — it asks *"did the polish do harm"*. Asking a critic
+*"what is wrong with this stack"* answers from an unbounded set, so any blocker
+that sample happened to roll — including one present all along that the green gate
+had simply not sampled — reached the table's third arm as *"a blocker the polish
+introduced"* and **reverted a correct, behaviour-preserving refactor**, reporting
+`simplify=reverted` to an operator whose polish was fine.
+
+**The scope now comes from the checkout, not from an argument.** `### 4b` commits
+the polish and deliberately does **not** push it; `### 4c` reviews with a level and
+no target at all, so the reviewer's own default — `git diff @{upstream}...HEAD`,
+with upstream still at the pre-simplify SHA — resolves to exactly the polish
+commit. 4c then pushes (a new `premerge-simplify-push` fence, carrying the branch
+assertion and the bounded stderr capture the old inline push had) and gates.
+
+That push runs **regardless of `--no-post-simplify-review`**, and only the review,
+triage and gate steps are gated on it. Moving the push into 4c without that carve-out
+would have put the *only* push of the simplify commit behind the flag: on
+`/premerge --no-post-simplify-review --no-bump`, or on any repo without the version
+ratchet, the polish would be committed locally, never pushed, absent from the stack
+PR, and destroyed by the next `git reset --hard origin/...`. Both `commands/premerge.md`
+and RFC 0021 document that flag as costing the verification, never the polish.
+
+4c also gained a third arm for `### 4b` **exiting non-zero** (wrong branch, untracked
+files, absent allowed set, stray files). Each of those leaves the lens edits
+uncommitted in a dirty tree, where the reviewer's empty-range fallback would sweep
+the scope-rejected edits into the review; the arm stops the run instead.
+
+Passing the range explicitly was tried first and rejected. On the default cell the
+target is prose the model may or may not honour, and an **ignored target does not
+degrade to a wider review — it degrades to an empty one**: it falls back to that
+same default, which on an already-pushed branch is an empty range over a clean
+tree, so zero findings and a vacuous green from the phase whose whole job is to
+catch a bad polish. Leaving the commit unpushed is what makes the default correct
+rather than empty.
+
+Also fixed while here: 4c had no arm for `### 4b`'s `COMMIT=none REASON=no-edits`
+early exit, so a lens pass that applied nothing sent 4c to verify a commit that was
+never made. It now skips to Phase 5.
+
+### Fixed — a claim about the built-in reviewer that was asserted rather than executed
+
+RFC 0021 A3 **C8** recorded *"a two-SHA range is not in that surface"*, and
+`## Phase 3b — CONVERGE` plus `references/common-mistakes.md` both repeated it.
+It had been read off the review prompt's own enumeration rather than executed
+against the invocation path. Read out of the shipped binary (`2.1.241`):
+
+- the argument parser (`hLs` → `qau`) joins every post-level token into one
+  free-text target and rejects no shape;
+- `o30` takes either no target or one matching
+  `^[@\w][@\w./~^-]*\.\.\.?[@\w][@\w./~^-]*$` and returns on everything else — so
+  a range is the **only** target form that code parses; a PR number, a branch and
+  a path all fall through it. "Not in that surface" is backwards.
+
+The bound matters as much as the retraction, and is recorded with it: `o30` runs
+only when the cell sets `finderBudgetHint`, which `O_e` sets **false** for
+`o48-xhigh-v1` — the cell `claude-opus-5` xhigh resolves to, and `xhigh` is
+`PREMERGE_DEFAULT_LEVEL`. On /premerge's own default cell the CLI never parses the
+target at all. That bound is why 4c passes no target rather than a range.
+
+What survives of C8 is the point the growth ratio actually needs: a range would
+scope the *review*, but findings come back carrying `file` and `line` and no hunk
+provenance — so file-membership stays the honest proxy. C8 is amended in place
+rather than rewritten, and the two downstream copies now say the same thing.
+
 ## [0.56.1] — 2026-08-24
 
 ### Changed — the project rule file is `CLAUDE.md`, not `AGENTS.md`

README.md

@@ -4,7 +4,7 @@
 
 **Personal Claude Code marketplace — opinionated GitHub-workflow slash commands.**
 
-[![Version](https://img.shields.io/badge/version-0.56.1-blue)](./CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-0.56.2-blue)](./CHANGELOG.md)
 [![License](https://img.shields.io/badge/license-MIT-green)](./LICENSE)
 [![Claude Code](https://img.shields.io/badge/Claude%20Code-plugin-8B5CF6)](https://docs.claude.com/en/docs/claude-code/plugins)
 [![Repo Agnostic](https://img.shields.io/badge/repo--agnostic-yes-success)](#configuration)

docs/rfc/0021-premerge-stack-integration.md

@@ -647,10 +647,12 @@ findings, and the second round's six were all in text the first round's fixes ha
 just written — the amendment reproducing, on itself, the defect it documents. Two
 of those were structural rather than cosmetic: the design named `refuted` as a
 gate-closing state while defining a producer only for `fixed`, and it prescribed
-reviewing a two-SHA range through a dispatch surface that accepts only a PR, a
-branch or a path. A design with a state nothing can produce and a keystone
+reviewing a two-SHA range through a dispatch surface believed to accept only a
+PR, a branch or a path. A design with a state nothing can produce and a keystone
 nothing can invoke is a sketch, and a sketch attracts "you did not specify X"
-without bound.
+without bound. (The second of those two was itself wrong about the reviewer —
+see C8's 2026-08-24 amendment. The *shape* of the criticism held: the keystone
+was asserted, not executed. Executing it is what found the range regex.)
 
 So what A3 ratifies is the diagnosis above — every pointer in it executed and
 confirmed — plus the constraint set below. Each constraint is a way the obvious
@@ -721,11 +723,51 @@ carried as a retained backstop.
 
 **C8 — the incremental review needs a dispatch that exists.** The only reviewer
 the pipeline has is the built-in `code-review` skill (`SKILL.md:584`), whose
-accepted targets are a PR number, a branch, or a path; the no-target default is
-`git diff @{upstream}...HEAD` plus the working tree. A two-SHA range is not in
-that surface. C1 needs a path set derived from the repair diff, a locally-arranged
-checkout the default picks up, or an extension to the target surface — named
-explicitly, because "review the delta" is not yet an invocation.
+Phase 0 enumerates a PR number, a branch, or a path; the no-target default is
+`git diff @{upstream}...HEAD` plus the working tree.
+
+> **Amended 2026-08-24 (#795).** This constraint originally read *"a two-SHA range
+> is not in that surface"*. That is **false**, and it was asserted from the prompt's
+> enumeration rather than executed against the invocation path. Read out of the
+> shipped binary (`2.1.241`), in three parts, because only the first two support the
+> retraction and the third bounds it:
+>
+> 1. **The parser passes anything through.** `hLs` splits the post-level remainder
+>    on whitespace and `qau` joins every token back into ONE free-text target
+>    string. No shape is rejected.
+> 2. **The CLI carries an explicit range path.** `o30` accepts either no target — in
+>    which case it uses `@{upstream}...HEAD` — or a target of at most 256 chars
+>    matching `^[@\w][@\w./~^-]*\.\.\.?[@\w][@\w./~^-]*$`, on which it runs
+>    `git diff --no-ext-diff --no-textconv --numstat --end-of-options <target> --`,
+>    and it `return`s on every other shape. A range is the *only* target form that
+>    code parses at all; a PR number, a branch and a path all fall straight through
+>    it. "Not in that surface" is exactly backwards.
+> 3. **On the cell /premerge actually runs, that path is dead.** `o30` is reached
+>    only from `n30`, which returns immediately unless the cell sets
+>    `finderBudgetHint`. `O_e` — the constructor every non-Sonnet cell is built
+>    from — sets it **false**, and `claude-opus-5` xhigh resolves to
+>    `O_e("o48-xhigh-v1")`. `PREMERGE_DEFAULT_LEVEL` is `xhigh`. So on the default
+>    cell nothing in the CLI parses the target; it reaches the model as prose, under
+>    a Phase 0 that says *"review that target instead. Treat this diff as the review
+>    scope."*
+>
+> Net: a range is a legitimate, recognised target shape, and on the default cell it
+> is **interpreted rather than enforced**. `### 4c — VERIFY` therefore does **not**
+> pass one. An ignored target does not degrade to a wider review — it degrades to
+> the no-target default, which on an already-pushed branch is an empty range, a
+> clean tree and zero findings: a vacuous green from the one phase that exists to
+> catch a bad polish. 4c instead leaves the polish commit unpushed until after the
+> review, so that default resolves to exactly the polish and no target is needed.
+>
+> What survives of C8 is the narrower point C1 actually needs: a range scopes the
+> **review**, but the findings that come back carry `file` and `line` and no hunk
+> provenance, so per-finding attribution to *"text the previous repair wrote"* is
+> still not purchasable this way.
+
+C1 still needs a path set derived from the repair diff, a locally-arranged
+checkout the default picks up, or per-finding provenance — named explicitly,
+because "review the delta *and know which findings are about it*" is still not
+yet an invocation.
 
 **On the narrow verifier.** The instinct behind C4 — that checking must be
 cheaper than discovering, and structurally unable to emit new findings — is sound
@@ -986,9 +1028,10 @@ rediscovering them.
 landed in text the previous repair *wrote*; what is measured is whether it
 landed in a **file** that repair modified. A genuinely new defect four hundred
 lines from the repair hunk counts as growth. The precise version needs diff-hunk
-mapping against a review pointed at one repair's delta, and C8 records that no
-such dispatch exists — the only reviewer this pipeline has accepts a PR, a
-branch or a path, and a two-SHA range is not in that surface. So the proxy errs
+mapping against a review pointed at one repair's delta. Pointing a review at that
+delta is available — C8's amendment records the range target form, which `### 4c`
+deliberately does not use — but findings carry `file`, `line` and no provenance, so
+the mapping still has nothing to key on. So the proxy errs
 toward stopping, which is what the two-round requirement exists to absorb.
 Making it precise belongs to the C1–C8 work, not to a follow-up on this one.
 

plugins/uberdev/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "uberdev",
-  "version": "0.56.1",
+  "version": "0.56.2",
   "description": "Production-grade Claude Code plugin: parallel-fanout PR review, autonomous GitHub issue triage and resolution via Workflow-native solver fleets (one worktree-isolated agent per issue; detached wezterm / background transports remain opt-in; cross-platform — macOS, Linux, WSL2, native Windows), brainstorm/plan/execute workflows with wave-based subagent dispatch.",
   "author": {
     "name": "TheFJK",