git-review-workflow 0.1.0

package/bin/git-review-lib.sh

@@ -0,0 +1,121 @@
+#!/usr/bin/env sh
+#
+# git-review-lib.sh — helpers shared by the git review step commands.
+#
+# This file is *sourced, never run*. The verbs that need the helpers below
+# (start, next, prev, continue, compare) load it as
+# "${GIT_REVIEW_LIBEXEC:?}/git-review-lib.sh" — GIT_REVIEW_LIBEXEC is exported by
+# the git-review dispatcher before it execs the verb, and points at the real
+# directory where the dispatcher, this lib and the git-review-verbs/ directory
+# live together (installed as libexec, not on PATH). It only defines functions,
+# so sourcing it has no side effects.
+
+# show_commit <commit> <n> <total>
+# Print a commit's diffstat first and its identifying header last, so the header
+# stays next to the prompt instead of scrolling off the top when the diffstat is
+# long for a commit that touches many files.
+show_commit() {
+	git --no-pager show --stat --format='' "$1"
+	printf -- '----\n[%s/%s] %s\n%s\n\n%s\n----\nreview this commit, edit files, then run git review next\n' \
+		"$2" "$3" "$(git rev-parse --short "$1")" \
+		"$(git show -s --format='%an <%ae>' "$1")" \
+		"$(git show -s --format='%s%n%n%b' "$1")"
+}
+
+# load_step_review_meta
+# Confirm HEAD is on a review/* branch started with --step and load its metadata
+# into the globals the caller and goto_step rely on: cur, src, tip, start, count,
+# step, commits and total. Exits with a diagnostic on any inconsistency (wrong
+# branch, wrong mode, or missing/corrupt metadata).
+load_step_review_meta() {
+	cur="$(git symbolic-ref --quiet --short HEAD || true)"
+	[ -n "$cur" ] || {
+		echo "error: not on a branch" >&2
+		exit 1
+	}
+	case "$cur" in
+	review/*) ;;
+	*)
+		echo "error: not on a review/* branch (HEAD is $cur)" >&2
+		exit 1
+		;;
+	esac
+
+	mode="$(git config "branch.$cur.reviewmode" || true)"
+	[ "$mode" = "step" ] || {
+		echo "error: $cur was not started with git review start --step" >&2
+		exit 1
+	}
+
+	src="$(git config "branch.$cur.reviewsource" || true)"
+	tip="$(git config "branch.$cur.reviewtip" || true)"
+	start="$(git config "branch.$cur.reviewstart" || true)"
+	count="$(git config "branch.$cur.reviewcount" || true)"
+	step="$(git config "branch.$cur.reviewstep" || true)"
+
+	# A key deleted by a hand-edit (while reviewmode stays "step") would otherwise
+	# let set -e kill us silently mid-script; read with || true and report it.
+	if [ -z "$src" ] || [ -z "$tip" ] || [ -z "$start" ] || [ -z "$count" ]; then
+		echo "error: missing review metadata; was $cur created with git review start?" >&2
+		exit 1
+	fi
+
+	commits="$(git rev-list --reverse --first-parent --no-merges "$start..$tip")"
+
+	# Guard against a step that maps to no commit (corrupt config, hand-edited
+	# metadata): otherwise goto_step's sed yields an empty commit and git rev-parse
+	# '^{tree}' crashes mid-move.
+	total="$(printf '%s\n' "$commits" | grep -c .)"
+	case "$count" in
+	*[!0-9]*)
+		echo "error: corrupt review metadata: reviewcount is '$count', not a positive integer" >&2
+		exit 1
+		;;
+	esac
+	[ "$count" -ge 1 ] || {
+		echo "error: corrupt review metadata: reviewcount is '$count', not a positive integer" >&2
+		exit 1
+	}
+	case "$step" in
+	'' | *[!0-9]*)
+		echo "error: corrupt review metadata: reviewstep is '$step', not a positive integer" >&2
+		exit 1
+		;;
+	esac
+	if [ "$step" -lt 1 ] || [ "$step" -gt "$total" ]; then
+		echo "error: review step $step out of range (1..$total) — corrupt metadata?" >&2
+		exit 1
+	fi
+}
+
+# goto_step <target>
+# Move a --step review to step <target>: bank the current commit's edits, reset
+# clean to the target commit, restore the target's previously banked edits (if
+# any), then soft-reset so its diff is staged. Relies on the globals set by
+# load_step_review_meta (cur, src, count, step, commits).
+goto_step() {
+	target="$1"
+	cstep="$(printf '%s\n' "$commits" | sed -n "${step}p")"
+	git add -A
+	tree="$(git write-tree)"
+	if [ "$tree" != "$(git rev-parse "$cstep^{tree}")" ]; then
+		edit="$(git commit-tree "$tree" -p "$cstep" -m "review edits step $step")"
+		git update-ref "refs/review-edits/$src/$step" "$edit"
+	else
+		# Reverting the step back to a clean tree must clear any edits we banked
+		# earlier, or they resurrect on the next visit / at git review finish.
+		git update-ref -d "refs/review-edits/$src/$step" 2>/dev/null || true
+	fi
+	ctarget="$(printf '%s\n' "$commits" | sed -n "${target}p")"
+	git reset -q --hard "$ctarget"
+	ref="refs/review-edits/$src/$target"
+	if git rev-parse --verify --quiet "$ref" >/dev/null; then
+		git diff --binary "${ref}^" "$ref" | git apply || {
+			echo "error: could not restore banked edits for step $target" >&2
+			exit 1
+		}
+	fi
+	git reset -q --soft "$ctarget^"
+	git config "branch.$cur.reviewstep" "$target"
+	show_commit "$ctarget" "$target" "$count"
+}

package/bin/git-review-verbs/abort

@@ -0,0 +1,101 @@
+#!/usr/bin/env sh
+#
+# git review abort — cancel the review on the current branch in one step.
+#
+# Returns you to the branch you started from (or the base), deletes the
+# review/<branch> branch and its banked edits. Because the review was cancelled,
+# it also rolls the --delta marker back to your last actual review.
+#
+set -eu
+
+prog="git review abort"
+
+usage() {
+	cat <<EOF
+usage: $prog
+
+Cancel the current review: return to the starting branch, then delete the
+review/<branch> branch and any banked commit-by-commit edits.
+EOF
+}
+
+case "${1:-}" in
+-h | --h)
+	usage
+	exit 0
+	;;
+"") ;;
+*)
+	echo "error: unexpected argument $1" >&2
+	usage >&2
+	exit 1
+	;;
+esac
+
+cur="$(git symbolic-ref --quiet --short HEAD || true)"
+case "$cur" in
+review/*) ;;
+*)
+	echo "error: not on a review/* branch (HEAD is ${cur:-detached})" >&2
+	exit 1
+	;;
+esac
+
+src="$(git config "branch.$cur.reviewsource" || true)"
+[ -n "$src" ] || {
+	echo "error: missing review metadata; was $cur created with git review start?" >&2
+	exit 1
+}
+base="$(git config "branch.$cur.reviewbase" || true)"
+ret="$(git config "branch.$cur.reviewreturn" || true)"
+prevreviewed="$(git config "branch.$cur.reviewprevreviewed" || true)"
+
+# A local review tracks its delta progress under a separate config section
+# (reviewworkflowlocal.*); roll back the matching one so a cancelled review never
+# corrupts either side's progress.
+if [ "$(git config "branch.$cur.reviewlocal" || true)" = "1" ]; then
+	markerkey="reviewworkflowlocal.$src.reviewed"
+else
+	markerkey="reviewworkflow.$src.reviewed"
+fi
+
+target=""
+if [ -n "$ret" ] && git rev-parse --verify --quiet "refs/heads/$ret" >/dev/null; then
+	target="$ret"
+elif [ -n "$base" ] && git rev-parse --verify --quiet "refs/heads/$base" >/dev/null; then
+	target="$base"
+fi
+[ -n "$target" ] || {
+	echo "error: could not determine a branch to return to; switch away manually, then run git review clean $src" >&2
+	exit 1
+}
+
+git switch -q --discard-changes "$target"
+git branch -D "$cur" >/dev/null
+
+# This review was cancelled, not completed: undo the reviewed marker it set,
+# restoring the tip of your last actual review (or clearing it if there was none)
+# so a later --delta does not skip commits you never reviewed.
+if [ -n "$prevreviewed" ]; then
+	git config "$markerkey" "$prevreviewed"
+else
+	git config --unset "$markerkey" 2>/dev/null || true
+fi
+
+git for-each-ref --format='%(refname)' "refs/review-edits/$src/" | while read -r ref; do
+	git update-ref -d "$ref"
+done
+
+# Cancelling the review tears down everything it spawned. If you had already run
+# git review finish, that left a review-fixes/<branch> and a finish undo point
+# (refs/review-undo/<branch>/*) behind; drop them too so an abort leaves nothing
+# dangling. The undo *config* rode on branch.review/<branch> and was already
+# removed when the branch was deleted above.
+if git rev-parse --verify --quiet "refs/heads/review-fixes/$src" >/dev/null; then
+	git branch -D "review-fixes/$src" >/dev/null
+fi
+git for-each-ref --format='%(refname)' "refs/review-undo/$src/" | while read -r ref; do
+	git update-ref -d "$ref"
+done
+
+echo "aborted review of $src; returned to $target"

package/bin/git-review-verbs/clean

@@ -0,0 +1,123 @@
+#!/usr/bin/env sh
+#
+# git review clean — delete the review/<branch> and review-fixes/<branch> branches.
+#
+# With no <branch> it deletes all of them. It never deletes the branch you are
+# currently on. The recorded last-reviewed tip (used by --delta) is left alone;
+# discard it with git review forget --delta.
+#
+set -eu
+
+prog="git review clean"
+
+usage() {
+	cat <<EOF
+usage: $prog [branch]
+
+Delete the review/<branch> and review-fixes/<branch> branches.
+With no <branch>, delete all of them.
+
+The --delta marker is left untouched; use git review forget --delta to discard it.
+EOF
+}
+
+arg=""
+while [ $# -gt 0 ]; do
+	case "$1" in
+	-h | --h)
+		usage
+		exit 0
+		;;
+	-*)
+		echo "error: unknown option $1" >&2
+		usage >&2
+		exit 1
+		;;
+	*)
+		if [ -z "$arg" ]; then
+			arg="$1"
+		else
+			echo "error: unexpected argument $1" >&2
+			exit 1
+		fi
+		;;
+	esac
+	shift
+done
+
+cur="$(git symbolic-ref --quiet --short HEAD || true)"
+
+if [ -n "$arg" ]; then
+	list="review/$arg review-fixes/$arg"
+else
+	list="$(git for-each-ref --format='%(refname:short)' refs/heads/review/ refs/heads/review-fixes/)"
+fi
+
+# Track whether any cleanup actually happened so the closing message is honest:
+# deleting orphaned refs counts as work even when no review branches exist.
+cleaned=0
+
+# No branches is not a stopping point: banked edit refs can still be orphaned
+# and need dropping, so fall through to that cleanup instead of bailing here.
+if [ -n "$list" ]; then
+	# Word splitting is intentional: branch names cannot contain whitespace.
+	# shellcheck disable=SC2086
+	for b in $list; do
+		git rev-parse --verify --quiet "refs/heads/$b" >/dev/null || continue
+		if [ "$b" = "$cur" ]; then
+			echo "skipping $b (currently checked out)" >&2
+			continue
+		fi
+		git branch -D "$b"
+		cleaned=1
+	done
+fi
+
+# Drop any banked commit-by-commit edit refs, plus any git review finish undo points
+# (refs/review-undo/* and their branch.review/<branch>.reviewundo* config) left
+# behind by a finish that was never aborted.
+if [ -n "$arg" ]; then
+	editns="refs/review-edits/$arg/"
+	undons="refs/review-undo/$arg/"
+	undobranches="$arg"
+else
+	editns="refs/review-edits/"
+	undons="refs/review-undo/"
+	undobranches="$(git for-each-ref --format='%(refname)' refs/review-undo/ |
+		sed -n 's#^refs/review-undo/\(.*\)/[^/]*$#\1#p' | sort -u)"
+fi
+for ns in "$editns" "$undons"; do
+	# Read refs into a variable first: a `... | while read` pipeline runs the
+	# loop body in a subshell, so a `cleaned=1` set there would not survive.
+	refs="$(git for-each-ref --format='%(refname)' "$ns")"
+	[ -n "$refs" ] || continue
+	echo "$refs" | while read -r ref; do
+		git update-ref -d "$ref"
+	done
+	cleaned=1
+done
+# Word splitting is intentional: branch names cannot contain whitespace.
+# shellcheck disable=SC2086
+for b in $undobranches; do
+	for k in reviewundohead reviewundokind reviewundosrccreated \
+		reviewundoeditstep reviewundoeditold reviewundoouthead reviewundoouttree; do
+		git config --unset "branch.review/$b.$k" 2>/dev/null || true
+	done
+done
+
+if [ "$cleaned" -eq 0 ]; then
+	# Saved reviews live in review-saved/*, a namespace git review clean deliberately
+	# leaves alone (it owns review/* and review-fixes/* only). Point at them when
+	# nothing else was found, so "no review branches" does not read as wrong to
+	# someone staring at a review-saved/<branch> they expected this to clear.
+	if [ -n "$arg" ]; then
+		saved="$(git for-each-ref --format='%(refname:short)' "refs/heads/review-saved/$arg")"
+	else
+		saved="$(git for-each-ref --format='%(refname:short)' refs/heads/review-saved/)"
+	fi
+	if [ -n "$saved" ]; then
+		echo "no review/ or review-fixes/ branches to clean; you have a saved review — resume it with git review continue or discard it with git review forget --saved" >&2
+	else
+		echo "no review branches found" >&2
+	fi
+fi

package/bin/git-review-verbs/compare

@@ -0,0 +1,159 @@
+#!/usr/bin/env sh
+#
+# git review compare <a> <b> — stage the diff between two commit-ish, read-only.
+#
+# Unlike git review start, compare has no writable source branch: it materialises
+# the diff <a>..<b> (with <a> the lower bound, <b> the tip) as a staged, read-only
+# review you can annotate inline. There is nothing to extract, so git review finish
+# refuses on it. With --step it walks <a>..<b> one commit at a time, like start
+# --step, advancing with git review next.
+#
+set -eu
+
+prog="git review compare"
+
+usage() {
+	cat <<EOF
+usage: $prog <a> <b> [--step]
+
+Stage the diff between two commit-ish on a review/<b> branch for inline reading.
+This is a read-only review: there is no branch to write back to, so git review
+finish refuses on it.
+
+  <a>        the lower bound (a branch, tag or commit) — what to diff from
+  <b>        the upper bound — what to diff to; names the review branch
+  --step     read one commit at a time; advance with git review next
+EOF
+}
+
+die() {
+	echo "error: $1" >&2
+	exit 1
+}
+
+a=""
+b=""
+have_a=0
+have_b=0
+step=0
+# Collect the two positional commit-ish; mirror start's parser, including -- as the
+# end-of-options separator so a commit-ish that starts with "-" stays positional.
+add_positional() {
+	if [ "$have_a" -eq 0 ]; then
+		a="$1"
+		have_a=1
+	elif [ "$have_b" -eq 0 ]; then
+		b="$1"
+		have_b=1
+	else
+		die "unexpected argument $1"
+	fi
+}
+while [ $# -gt 0 ]; do
+	case "$1" in
+	-h | --h)
+		usage
+		exit 0
+		;;
+	--step) step=1 ;;
+	--)
+		shift
+		while [ $# -gt 0 ]; do
+			add_positional "$1"
+			shift
+		done
+		break
+		;;
+	-*)
+		echo "error: unknown option $1" >&2
+		usage >&2
+		exit 1
+		;;
+	*)
+		add_positional "$1"
+		;;
+	esac
+	shift
+done
+
+if [ "$have_a" -ne 1 ] || [ "$have_b" -ne 1 ]; then
+	die "need two commit-ish to compare: $prog <a> <b>"
+fi
+
+git rev-parse --git-dir >/dev/null 2>&1 || die "not a git repository"
+
+# Shared helpers, sourced from the libexec directory the dispatcher points us at.
+# shellcheck source=../git-review-lib.sh
+. "${GIT_REVIEW_LIBEXEC:?}/git-review-lib.sh"
+
+acommit="$(git rev-parse --verify --quiet "$a^{commit}")" || die "unknown commit: $a"
+bcommit="$(git rev-parse --verify --quiet "$b^{commit}")" || die "unknown commit: $b"
+[ "$acommit" != "$bcommit" ] || die "$a and $b are the same commit; nothing to compare"
+
+if ! git diff --quiet || ! git diff --cached --quiet; then
+	die "you have local changes; commit or stash them first"
+fi
+
+# Remember where to return to when the compare is aborted.
+returnbranch="$(git symbolic-ref --quiet --short HEAD || true)"
+
+# Pick a refname-safe identity for the review branch from <b> (the tip). A tag or
+# branch name passes through unchanged, for a readable review/<b>; anything git
+# would reject as a ref component (HEAD~3, a^, x:y) falls back to <b>'s short hash,
+# so the branch and the per-step edit refs (refs/review-edits/<name>/*) are always
+# valid. This name is the review's identity for status/list/clean, never a writeback
+# target — compare is read-only.
+if git check-ref-format "review/$b" 2>/dev/null; then
+	name="$b"
+else
+	name="$(git rev-parse --short "$bcommit")"
+fi
+
+rb="review/$name"
+git rev-parse --verify --quiet "refs/heads/$rb" >/dev/null &&
+	die "$rb already exists; run git review clean $name first"
+git rev-parse --verify --quiet "refs/heads/review-saved/$name" >/dev/null &&
+	die "you have a saved review of $name; resume it with git review continue $name or discard it with git review forget --saved $name"
+
+if [ "$step" -eq 1 ]; then
+	# --first-parent --no-merges: walk only the range's own commits, skipping merge
+	# commits, exactly like start --step so git review next/prev behave identically.
+	commits="$(git rev-list --reverse --first-parent --no-merges "$acommit..$bcommit")"
+	[ -n "$commits" ] || die "no commits to compare in range $a..$b"
+	count="$(printf '%s\n' "$commits" | wc -l | tr -d ' ')"
+	first="$(printf '%s\n' "$commits" | sed -n '1p')"
+
+	git switch -q -c "$rb" "$first" || die "could not create $rb"
+	git reset --soft HEAD^
+	git config "branch.$rb.reviewsource" "$name"
+	git config "branch.$rb.reviewbase" "$a"
+	git config "branch.$rb.reviewtip" "$bcommit"
+	git config "branch.$rb.reviewstart" "$acommit"
+	git config "branch.$rb.reviewmode" "step"
+	git config "branch.$rb.reviewcount" "$count"
+	git config "branch.$rb.reviewstep" "1"
+	git config "branch.$rb.reviewreadonly" "1"
+	if [ -n "$returnbranch" ]; then
+		git config "branch.$rb.reviewreturn" "$returnbranch"
+	fi
+
+	echo "$rb ready (compare $a..$b, read-only) — walking $count commit(s) one at a time"
+	show_commit "$first" 1 "$count"
+	exit 0
+fi
+
+# Whole range: create review/<name> at <b> and soft-reset to <a> so the staged diff
+# is exactly <a>..<b>, with a clean working tree — the same shape as start, minus the
+# merged-base folding (compare's bounds are explicit) and any writeback metadata.
+git switch -q -c "$rb" "$bcommit" || die "could not create $rb"
+git reset -q --soft "$acommit"
+
+git config "branch.$rb.reviewsource" "$name"
+git config "branch.$rb.reviewbase" "$a"
+git config "branch.$rb.reviewtip" "$bcommit"
+git config "branch.$rb.reviewreadonly" "1"
+if [ -n "$returnbranch" ]; then
+	git config "branch.$rb.reviewreturn" "$returnbranch"
+fi
+
+echo "$rb ready (compare $a..$b, read-only) — the staged diff is for reading; git review finish will refuse"

package/bin/git-review-verbs/continue

@@ -0,0 +1,178 @@
+#!/usr/bin/env sh
+#
+# git review continue — resume a review put aside with git review save.
+#
+# It turns review-saved/<branch> back into the active review/<branch>, restoring
+# the exact state you left: in whole mode the staged PR diff with your edits in the
+# working tree; in step mode the commit you were on, its edits, and every other
+# banked edit — so review-next / review-prev keep working as before.
+#
+# With no argument it resumes the only saved review, or lists them if there is more
+# than one. Name a branch to pick a specific one.
+#
+set -eu
+
+prog="git review continue"
+
+usage() {
+	cat <<EOF
+usage: $prog [<branch>]
+
+Resume a review saved with git review save. With no argument, resume the only
+saved review (or list them if there is more than one).
+EOF
+}
+
+die() {
+	echo "error: $1" >&2
+	exit 1
+}
+
+arg=""
+while [ $# -gt 0 ]; do
+	case "$1" in
+	-h | --h)
+		usage
+		exit 0
+		;;
+	-*)
+		echo "error: unknown option $1" >&2
+		usage >&2
+		exit 1
+		;;
+	*)
+		if [ -z "$arg" ]; then
+			arg="$1"
+		else
+			die "unexpected argument $1"
+		fi
+		;;
+	esac
+	shift
+done
+
+git rev-parse --git-dir >/dev/null 2>&1 || die "not a git repository"
+
+# Shared helpers, sourced from the libexec directory the dispatcher points us at.
+# shellcheck source=../git-review-lib.sh
+. "${GIT_REVIEW_LIBEXEC:?}/git-review-lib.sh"
+
+# Pick the saved review to resume.
+if [ -n "$arg" ]; then
+	src="$arg"
+	saved="review-saved/$src"
+	git rev-parse --verify --quiet "refs/heads/$saved" >/dev/null ||
+		die "no saved review for $src (looked for $saved)"
+else
+	branches="$(git for-each-ref --format='%(refname:short)' refs/heads/review-saved/)"
+	[ -n "$branches" ] || die "no saved reviews; save one with git review save"
+	n="$(printf '%s\n' "$branches" | wc -l | tr -d ' ')"
+	if [ "$n" -gt 1 ]; then
+		echo "more than one saved review — name the one to resume:" >&2
+		printf '%s\n' "$branches" | sed -n 's#^review-saved/#  git review continue #p' >&2
+		exit 1
+	fi
+	saved="$branches"
+	src="${saved#review-saved/}"
+fi
+
+rb="review/$src"
+git rev-parse --verify --quiet "refs/heads/$rb" >/dev/null &&
+	die "$rb is already active; finish or abort it before resuming the saved one"
+
+# Resuming materialises a working tree, so refuse to clobber local changes.
+if ! git diff --quiet || ! git diff --cached --quiet; then
+	die "you have local changes; commit or stash them first"
+fi
+
+mode="$(git config "branch.$saved.reviewmode" || echo whole)"
+tip="$(git config "branch.$saved.reviewtip" || true)"
+# A saved review missing its tip (hand-edited or half-deleted config) would let
+# set -e kill us silently while restoring; report it instead.
+[ -n "$tip" ] || die "missing review metadata for $saved; was it created with git review start?"
+
+# restore_meta <key>: copy branch.<saved>.<key> to branch.<rb>.<key> when set.
+# Explicit if so the function returns 0 for absent optional keys (set -e safety).
+restore_meta() {
+	v="$(git config "branch.$saved.$1" || true)"
+	if [ -n "$v" ]; then
+		git config "branch.$rb.$1" "$v"
+	fi
+}
+
+if [ "$mode" = "step" ]; then
+	start="$(git config "branch.$saved.reviewstart" || true)"
+	count="$(git config "branch.$saved.reviewcount" || true)"
+	step="$(git config "branch.$saved.reviewstep" || true)"
+	if [ -z "$start" ] || [ -z "$count" ] || [ -z "$step" ]; then
+		die "missing review metadata for $saved; was it created with git review start?"
+	fi
+
+	# Bring the banked edits back to where git review next/prev expect them.
+	git for-each-ref --format='%(refname)' "refs/review-saved-edits/$src/" | while read -r ref; do
+		n="${ref##*/}"
+		git update-ref "refs/review-edits/$src/$n" "$(git rev-parse "$ref")"
+		git update-ref -d "$ref"
+	done
+
+	commits="$(git rev-list --reverse --first-parent --no-merges "$start..$tip")"
+	cstep="$(printf '%s\n' "$commits" | sed -n "${step}p")"
+
+	# Land on the saved step exactly like review-next's goto_step does: hard-reset
+	# to the commit, re-apply its banked edits, then soft-reset so its diff is staged.
+	git switch -q -c "$rb" "$cstep"
+	ref="refs/review-edits/$src/$step"
+	if git rev-parse --verify --quiet "$ref" >/dev/null; then
+		git diff --binary "${ref}^" "$ref" | git apply ||
+			die "could not restore your edits for step $step"
+	fi
+	git reset -q --soft "$cstep^"
+
+	git config "branch.$rb.reviewmode" step
+	restore_meta reviewstart
+	restore_meta reviewcount
+	git config "branch.$rb.reviewstep" "$step"
+	restore_meta reviewsource
+	restore_meta reviewbase
+	restore_meta reviewtip
+	restore_meta reviewprevreviewed
+	restore_meta reviewlocal
+	restore_meta reviewreturn
+
+	git branch -D "$saved" >/dev/null
+
+	echo "resumed review of $src — step $step/$count"
+	show_commit "$cstep" "$step" "$count"
+else
+	# whole mode: rebuild the pristine review state (PR diff staged at the lower
+	# bound) and replay your edits into the working tree, leaving exactly what you
+	# had when you saved.
+	# Without || true a deleted reviewsavedlower (hand-edited or half-deleted
+	# config) would let set -e kill us mid-restore with no message; report it and
+	# bail before creating the review branch, the way the step path validates its
+	# keys above.
+	lower="$(git config "branch.$saved.reviewsavedlower" || true)"
+	[ -n "$lower" ] || die "missing review metadata for $saved; was it created with git review start?"
+
+	git switch -q -c "$rb" "$tip"
+	git reset -q --soft "$lower"
+	# Pipe the saved edits straight from git diff into git apply. Capturing the
+	# patch in a shell variable drops its NUL bytes and trailing newline, which
+	# corrupts a binary hunk and silently lost a binary edit on resume. The step
+	# path above (refs/review-edits) already pipes the diff directly.
+	if ! git diff --quiet "$tip" "$saved"; then
+		git diff --binary "$tip" "$saved" | git apply ||
+			die "could not restore your edits"
+	fi
+
+	restore_meta reviewsource
+	restore_meta reviewbase
+	restore_meta reviewtip
+	restore_meta reviewprevreviewed
+	restore_meta reviewlocal
+	restore_meta reviewreturn
+
+	git branch -D "$saved" >/dev/null
+
+	echo "resumed review of $src — the staged diff is the PR; edit, then run git review finish"
+fi