Skip to content

Worktrunk is a CLI for Git worktree management, designed for parallel AI agent workflows

fix(remove): atomic CAS branch deletion unifies safe-delete semantics (#2903)

Maximilian Roos1eb4e5897fae
diff --git a/src/git/remove.rs b/src/git/remove.rs
index 1069fc039..181a09227 100644
--- a/src/git/remove.rs
+++ b/src/git/remove.rs
@@ -225,6 +225,12 @@ impl BranchDeletionMode {
pub enum BranchDeletionOutcome {
/// Branch was not deleted — it was not integrated, and deletion was not forced.
NotDeleted,
+ /// Branch was integrated but the atomic compare-and-swap deletion was
+ /// rejected because the ref moved between the integration check and the
+ /// delete attempt — e.g. a hook or concurrent process advanced it. The
+ /// branch is retained (fail-closed), and the caller surfaces this as a
+ /// warning so the user can decide whether to re-check and delete.
+ RetainedRaced,
/// Branch was force-deleted without an integration check.
ForceDeleted,
/// Branch was deleted because it was integrated (the specific reason is attached).
@@ -412,8 +418,28 @@ pub fn delete_branch_if_safe(
let outcome = match reason {
Some(r) => {
- repo.run_command(&["branch", "-D", branch_name])?;
- BranchDeletionOutcome::Integrated(r)
+ // Atomic compare-and-swap against the snapshotted SHA. If the ref
+ // moved between `integration_reason` and the delete (e.g. a hook
+ // advanced the branch), `git update-ref -d <ref> <expected>` fails
+ // closed: the branch is retained and we surface a `RetainedRaced`
+ // outcome rather than dropping the unmerged commits silently.
+ //
+ // Read the SHA from the snapshot inventory (`local_branch`) rather
+ // than `resolve()`, so it reflects the same `refs/heads/` walk
+ // `integration_reason` consulted.
+ match snapshot.local_branch(branch_name) {
+ Some(b) => cas_delete_branch_outcome(repo, branch_name, &b.commit_sha, r)?,
+ // Snapshot doesn't carry the branch SHA — extremely unusual
+ // (the caller just captured refs, the branch is present in the
+ // integration check). Fall through to a non-CAS delete rather
+ // than failing the whole operation: this preserves the
+ // pre-CAS behavior in a corner case rather than introducing a
+ // new error class.
+ None => {
+ repo.run_command(&["branch", "-D", branch_name])?;
+ BranchDeletionOutcome::Integrated(r)
+ }
+ }
}
None => BranchDeletionOutcome::NotDeleted,
};
@@ -424,6 +450,46 @@ pub fn delete_branch_if_safe(
})
}
+/// Atomically delete `refs/heads/<branch>` iff it currently points at
+/// `expected_sha`, and translate the result into a [`BranchDeletionOutcome`].
+///
+/// `git update-ref -d <ref> <oid>` is git's compare-and-swap delete primitive:
+/// the ref is removed only if its current value matches `<oid>`. If it has
+/// moved (a hook or concurrent process advanced the branch), the command
+/// exits non-zero with a `cannot lock ref` message and the ref is left alone —
+/// fail-closed semantics that protect unmerged commits.
+///
+/// When `update-ref` fails, distinguishes "ref moved" (the ref still exists
+/// → `RetainedRaced`) from "real error" (the ref is gone or git itself
+/// failed → propagate the original error) by re-checking with `rev-parse
+/// --verify --quiet`, which has a structured exit code (0 = present, 1 =
+/// absent) rather than relying on locale-sensitive error-message text.
+fn cas_delete_branch_outcome(
+ repo: &Repository,
+ branch_name: &str,
+ expected_sha: &str,
+ reason: IntegrationReason,
+) -> anyhow::Result<BranchDeletionOutcome> {
+ let ref_name = format!("refs/heads/{branch_name}");
+ let update_err = match repo.run_command(&["update-ref", "-d", &ref_name, expected_sha]) {
+ Ok(_) => return Ok(BranchDeletionOutcome::Integrated(reason)),
+ Err(e) => e,
+ };
+
+ // CAS failed. Re-check the ref to distinguish a race rejection (ref
+ // moved → still present) from a true error (refs DB I/O, permissions,
+ // git missing → propagate). `rev-parse --verify --quiet` returns exit
+ // 0 when the ref exists, exit 1 when it does not — no message parsing.
+ if repo
+ .run_command(&["rev-parse", "--verify", "--quiet", &ref_name])
+ .is_ok()
+ {
+ Ok(BranchDeletionOutcome::RetainedRaced)
+ } else {
+ Err(update_err)
+ }
+}
+
/// Generate a staging path for worktree removal.
///
/// Places the staging directory inside `<git-common-dir>/wt/trash/` so it is
@@ -445,12 +511,143 @@ pub(crate) fn generate_removing_path(trash_dir: &Path, worktree_path: &Path) ->
#[cfg(test)]
mod tests {
use super::*;
+ use crate::testing::TestRepo;
+
+ /// When the branch tip moves between snapshot capture and the deletion
+ /// attempt, the atomic compare-and-swap rejects the delete and surfaces
+ /// `RetainedRaced` rather than dropping the new commits silently.
+ ///
+ /// The setup mimics a hook (or any concurrent writer) that advances the
+ /// branch after the planner observed it as integrated: we capture refs
+ /// when `feature` is at the same commit as `main` (trivially integrated),
+ /// then move `feature` forward, then call `delete_branch_if_safe` with
+ /// the stale snapshot. Integration check still says "integrated" (the
+ /// snapshotted SHA is reachable from main), but CAS catches the live
+ /// tip having moved and refuses the delete.
+ #[test]
+ fn cas_rejects_delete_when_branch_advances() {
+ let test = TestRepo::with_initial_commit();
+ test.run_git(&["branch", "feature"]);
+ let repo = Repository::at(test.root_path()).unwrap();
+
+ // Snapshot captures `feature` at the initial commit (same as `main`).
+ let snapshot = repo.capture_refs().unwrap();
+ let original_sha = snapshot.local_branch("feature").unwrap().commit_sha.clone();
+
+ // Race: advance `feature` after the snapshot.
+ test.run_git(&["checkout", "feature"]);
+ std::fs::write(test.root_path().join("race.txt"), "boom\n").unwrap();
+ test.run_git(&["add", "race.txt"]);
+ test.run_git(&["commit", "-m", "post-snapshot advance"]);
+ test.run_git(&["checkout", "main"]);
+
+ let advanced_sha = test.git_output(&["rev-parse", "feature"]);
+ assert_ne!(
+ original_sha, advanced_sha,
+ "test setup: tip must have moved"
+ );
+
+ let result = delete_branch_if_safe(&repo, &snapshot, "feature", "main", false).unwrap();
+ assert!(
+ matches!(result.outcome, BranchDeletionOutcome::RetainedRaced),
+ "expected RetainedRaced, got a different outcome"
+ );
+
+ // Branch survives, still at the post-race SHA.
+ let live = test.git_output(&["rev-parse", "feature"]);
+ assert_eq!(live, advanced_sha, "branch must not be deleted nor reset");
+ }
+
+ /// Plain integrated case still deletes via CAS. Sanity check that the
+ /// new code path doesn't break the common case.
+ #[test]
+ fn cas_deletes_when_branch_unchanged() {
+ let test = TestRepo::with_initial_commit();
+ test.run_git(&["branch", "feature"]);
+ let repo = Repository::at(test.root_path()).unwrap();
+
+ let snapshot = repo.capture_refs().unwrap();
+ let result = delete_branch_if_safe(&repo, &snapshot, "feature", "main", false).unwrap();
+ assert!(
+ matches!(result.outcome, BranchDeletionOutcome::Integrated(_)),
+ "expected Integrated, got a different outcome"
+ );
+
+ // Ref should be gone.
+ let exit = std::process::Command::new("git")
+ .args(["rev-parse", "--verify", "--quiet", "refs/heads/feature"])
+ .current_dir(test.root_path())
+ .status()
+ .unwrap();
+ assert!(!exit.success(), "branch should have been deleted");
+ }
+
+ /// When the branch ref vanishes between snapshot capture and the CAS
+ /// delete, `git update-ref -d` fails *and* the ref is already absent, so
+ /// the outcome is a real error (propagated) — distinct from the
+ /// `RetainedRaced` case where the ref moved but still exists.
+ #[test]
+ fn cas_propagates_error_when_ref_vanished() {
+ let test = TestRepo::with_initial_commit();
+ test.run_git(&["branch", "feature"]);
+ let repo = Repository::at(test.root_path()).unwrap();
+
+ // Snapshot captures `feature`, then it is deleted out-of-band.
+ let snapshot = repo.capture_refs().unwrap();
+ test.run_git(&["branch", "-D", "feature"]);
+
+ // Integration still reads "integrated" from the stale snapshot, the CAS
+ // update-ref fails, and rev-parse confirms the ref is gone → error.
+ let result = delete_branch_if_safe(&repo, &snapshot, "feature", "main", false);
+ assert!(
+ result.is_err(),
+ "expected a propagated error when the ref vanished, got Ok"
+ );
+ }
+
+ /// When the branch is integrated but absent from the captured snapshot
+ /// (created after capture), `integration_reason` still resolves it via the
+ /// live `rev-parse` fallback, yet the snapshot carries no SHA to CAS
+ /// against. The delete falls back to a plain `branch -D` and reports
+ /// `Integrated` — the non-CAS arm that exists for exactly this skew.
+ #[test]
+ fn deletes_via_fallback_when_branch_absent_from_snapshot() {
+ let test = TestRepo::with_initial_commit();
+ let repo = Repository::at(test.root_path()).unwrap();
+
+ // Capture refs BEFORE `feature` exists, so the snapshot carries no SHA
+ // for it (forcing the snapshot-miss, non-CAS arm).
+ let snapshot = repo.capture_refs().unwrap();
+ assert!(
+ snapshot.local_branch("feature").is_none(),
+ "test setup: snapshot must predate the branch"
+ );
+
+ // Create `feature` at main's commit → trivially integrated (same
+ // commit), resolvable live but missing from the stale snapshot.
+ test.run_git(&["branch", "feature"]);
+
+ let result = delete_branch_if_safe(&repo, &snapshot, "feature", "main", false).unwrap();
+ assert!(
+ matches!(result.outcome, BranchDeletionOutcome::Integrated(_)),
+ "expected Integrated via the non-CAS fallback"
+ );
+
+ // Branch was deleted.
+ let exit = std::process::Command::new("git")
+ .args(["rev-parse", "--verify", "--quiet", "refs/heads/feature"])
+ .current_dir(test.root_path())
+ .status()
+ .unwrap();
+ assert!(!exit.success(), "branch should have been deleted");
+ }
#[test]
fn test_branch_deletion_outcome_matching() {
// Ensure the match patterns work correctly
let outcomes = [
(BranchDeletionOutcome::NotDeleted, false),
+ (BranchDeletionOutcome::RetainedRaced, false),
(BranchDeletionOutcome::ForceDeleted, true),
(
BranchDeletionOutcome::Integrated(IntegrationReason::SameCommit),
diff --git a/src/output/handlers.rs b/src/output/handlers.rs
index 738660c3d..205138307 100644
--- a/src/output/handlers.rs
+++ b/src/output/handlers.rs
@@ -85,6 +85,14 @@ struct BackgroundRemoval<'a> {
target_branch: Option<&'a str>,
force_worktree: bool,
changed_directory: bool,
+ /// `true` when the planner already decided the branch would be retained
+ /// (unmerged, or `--no-delete-branch`) — `print_hints` has explained why,
+ /// so [`warn_if_branch_retained`] stays silent on the expected
+ /// `NotDeleted` outcome and only fires when the deletion command errors.
+ /// `false` means the planner predicted deletion; a `NotDeleted` here is a
+ /// race (e.g. `pre-remove` hook advanced the branch) that the user has
+ /// otherwise no signal for.
+ planner_expected_retention: bool,
}
/// How a background removal behaves when the rename-into-trash fast path fails.
@@ -94,8 +102,9 @@ pub enum BackgroundFallbackMode {
/// `wt remove`, `wt merge`, and the picker.
Detached,
/// Run the fallback removal and branch deletion synchronously for a
- /// non-current worktree. `wt step prune` uses this to keep the fallback's
- /// `.git/config` rewrite serialized with its integration-check readers.
+ /// non-current worktree. `wt step prune` uses this so each iteration's
+ /// removal completes before the next candidate is considered and before
+ /// the final summary is printed.
SynchronousForNonCurrent,
}
@@ -158,6 +167,7 @@ fn execute_instant_removal_or_fallback(
target_branch,
force_worktree,
changed_directory,
+ planner_expected_retention,
} = *removal;
if !force_worktree {
@@ -173,7 +183,8 @@ fn execute_instant_removal_or_fallback(
// decision: hooks or concurrent processes may have advanced the branch.
if let Some(branch) = branch_name
&& !deletion_mode.should_keep()
- && let Err(e) = repo.capture_refs().and_then(|snapshot| {
+ {
+ let result = repo.capture_refs().and_then(|snapshot| {
delete_branch_if_safe(
repo,
&snapshot,
@@ -181,9 +192,8 @@ fn execute_instant_removal_or_fallback(
target_branch.unwrap_or("HEAD"),
deletion_mode.is_force(),
)
- })
- {
- tracing::debug!(branch = %branch, error = %e, "Failed to delete branch {} synchronously: {}", branch, e);
+ });
+ warn_if_branch_retained(branch, &result, planner_expected_retention);
}
if changed_directory {
// Create an empty placeholder at the original path so the shell's working
@@ -207,15 +217,28 @@ fn execute_instant_removal_or_fallback(
if let Some(branch) = branch_name
&& !deletion_mode.should_keep()
{
- delete_branch_in_synchronous_fallback(repo, branch, target_branch, deletion_mode);
+ delete_branch_in_synchronous_fallback(
+ repo,
+ branch,
+ target_branch,
+ deletion_mode,
+ planner_expected_retention,
+ );
}
return Ok(BackgroundRemovalPlan::CompletedSynchronously);
}
// Fallback: cross-filesystem, permissions, Windows file locking, etc.
- // Use legacy git worktree remove which handles these cases. Safe-delete
- // uses Git's non-forcing branch deletion in the detached command; if
- // the branch gained unmerged commits after the hook, Git retains it.
+ // Use legacy git worktree remove which handles these cases. For
+ // safe-delete, decide here whether to append a branch-deletion step:
+ // run worktrunk's full integration check now, and if the branch is
+ // integrated, append an atomic `git update-ref -d <ref> <sha>` keyed
+ // to the snapshotted SHA. This matches the fast path and the
+ // synchronous fallback — same `BranchDeletionMode::SafeDelete` input
+ // yields the same semantics (squash-merged, ancestor, patch-id-match
+ // all accepted), and the CAS protects against tip movement between
+ // the foreground check and the detached delete. Force-delete keeps
+ // the unconditional `git branch -D` shell tail.
let command = match (branch_name, deletion_mode) {
(Some(branch), BranchDeletionMode::ForceDelete) => build_remove_command(
worktree_path,
@@ -223,12 +246,15 @@ fn execute_instant_removal_or_fallback(
force_worktree,
changed_directory,
),
- (Some(branch), BranchDeletionMode::SafeDelete) => build_remove_command_safe_delete(
- worktree_path,
- branch,
- force_worktree,
- changed_directory,
- ),
+ (Some(branch), BranchDeletionMode::SafeDelete) => {
+ let cas_tail = build_cas_branch_delete_tail(repo, branch, target_branch);
+ build_remove_command_with_tail(
+ worktree_path,
+ force_worktree,
+ changed_directory,
+ cas_tail.as_deref(),
+ )
+ }
_ => build_remove_command(worktree_path, None, force_worktree, changed_directory),
};
Ok(BackgroundRemovalPlan::Detached(command))
@@ -248,8 +274,9 @@ fn delete_branch_in_synchronous_fallback(
branch: &str,
target_branch: Option<&str>,
deletion_mode: BranchDeletionMode,
+ planner_expected_retention: bool,
) {
- if let Err(e) = repo.capture_refs().and_then(|snapshot| {
+ let result = repo.capture_refs().and_then(|snapshot| {
delete_branch_if_safe(
repo,
&snapshot,
@@ -257,23 +284,111 @@ fn delete_branch_in_synchronous_fallback(
target_branch.unwrap_or("HEAD"),
deletion_mode.is_force(),
)
- }) {
- tracing::debug!(branch = %branch, error = %e, "Failed to delete branch {branch} in synchronous fallback: {e}");
+ });
+ warn_if_branch_retained(branch, &result, planner_expected_retention);
+}
+
+/// Surface the residual branch when `delete_branch_if_safe` returned an
+/// unexpected outcome the user wouldn't otherwise see.
+///
+/// The worktree has already been removed by the time this runs, so silently
+/// dropping the branch-deletion outcome (the prior behavior) left the user
+/// with no signal that the branch survived. Both the fast path and the
+/// synchronous fallback route through here so the message is consistent.
+///
+/// - `Ok(RetainedRaced)`: atomic CAS rejected the delete because the ref
+/// tip moved between integration check and delete (a hook, a concurrent
+/// push). Always surface — the unmerged commits would otherwise vanish
+/// silently from the user's view.
+/// - `Ok(NotDeleted)`: integration check declined the branch. Warn only
+/// when the planner predicted deletion (a `pre-remove` hook commit, or
+/// similar race) — otherwise `print_hints` has explained the case and a
+/// second message would duplicate.
+/// - `Ok(ForceDeleted)` / `Ok(Integrated(_))`: succeeded; no message.
+/// - `Err`: `tracing::warn!` for developer diagnostics; the failure modes
+/// here (`git update-ref` exec error, refs DB I/O failure) are not
+/// user-actionable beyond re-running the command.
+fn warn_if_branch_retained(
+ branch: &str,
+ result: &anyhow::Result<BranchDeletionResult>,
+ planner_expected_retention: bool,
+) {
+ match result {
+ Ok(r) if matches!(r.outcome, BranchDeletionOutcome::RetainedRaced) => {
+ // The branch tip moved between the integration check and the
+ // atomic delete (a hook commit, a concurrent push). The
+ // compare-and-swap refused — fail-closed — so the unmerged
+ // commits are preserved. Always surface, regardless of planner
+ // prediction.
+ eprintln!("{}", retained_raced_branch_message(branch, true));
+ }
+ Ok(r)
+ if matches!(r.outcome, BranchDeletionOutcome::NotDeleted)
+ && !planner_expected_retention =>
+ {
+ let cmd = suggest_command("remove", &[branch], &["-D"]);
+ eprintln!(
+ "{}",
+ warning_message(cformat!(
+ "Removed worktree but kept branch <bold>{branch}</> (not integrated); to delete, run <bold>{cmd}</>"
+ ))
+ );
+ }
+ Err(e) => {
+ tracing::warn!(branch = %branch, error = %e, "Failed to delete branch {branch} after removing worktree: {e}");
+ }
+ Ok(_) => {}
}
}
-fn build_remove_command_safe_delete(
+/// Compute the safe-delete branch-deletion shell tail for the Detached
+/// fallback path.
+///
+/// Captures a fresh snapshot, runs the same `integration_reason` check the
+/// fast path uses, and — if the branch is integrated — returns an atomic
+/// `git update-ref -d refs/heads/<branch> <expected-sha>` that will be
+/// appended to the detached `git worktree remove` command. The CAS keeps the
+/// deletion safe against tip movement between this foreground check and the
+/// detached process executing it.
+///
+/// Returns `None` when the branch is not integrated, when the snapshot
+/// doesn't carry the branch SHA, or when the snapshot/integration call
+/// errors — all "don't delete" outcomes that preserve the pre-CAS detached
+/// behavior of skipping branch deletion.
+fn build_cas_branch_delete_tail(
+ repo: &Repository,
+ branch: &str,
+ target_branch: Option<&str>,
+) -> Option<String> {
+ use shell_escape::unix::escape;
+
+ let target = target_branch.unwrap_or("HEAD");
+ let snapshot = repo.capture_refs().ok()?;
+ let (_effective_target, reason) = repo.integration_reason(&snapshot, branch, target).ok()?;
+ reason?;
+ let expected_sha = snapshot.local_branch(branch)?.commit_sha.clone();
+
+ let ref_name = format!("refs/heads/{branch}");
+ let ref_escaped = escape(ref_name.as_str().into());
+ let sha_escaped = escape(expected_sha.as_str().into());
+ Some(format!("git update-ref -d {ref_escaped} {sha_escaped}"))
+}
+
+/// Build the detached worktree-removal command, optionally appending a
+/// branch-deletion tail (force-delete or CAS-delete) with `&&` so the branch
+/// step runs only when the worktree removal succeeded.
+fn build_remove_command_with_tail(
worktree_path: &Path,
- branch_name: &str,
force_worktree: bool,
changed_directory: bool,
+ tail: Option<&str>,
) -> String {
- use shell_escape::unix::escape;
-
let remove_command =
build_remove_command(worktree_path, None, force_worktree, changed_directory);
- let branch_escaped = escape(branch_name.into());
- format!("{remove_command} && git branch -d {branch_escaped}")
+ match tail {
+ Some(tail) => format!("{remove_command} && {tail}"),
+ None => remove_command,
+ }
}
/// List top-level entries remaining in a directory after a failed removal.
@@ -551,10 +666,36 @@ fn print_retained_unmerged_branch(branch_name: &str) {
eprintln!("{hint}");
}
+/// The canonical "branch retained because the atomic CAS delete was refused"
+/// warning. The ref moved between the integration check and the delete (a hook
+/// commit, a concurrent push), so the integrated branch is kept fail-closed
+/// rather than dropping the new commits. Shared across the worktree-removal and
+/// branch-only emit paths so the wording, flag, and styling can't drift.
+///
+/// `removed_worktree` selects the lead-in: the worktree has already been removed
+/// on the worktree-removal paths, but the branch-only path never had one.
+fn retained_raced_branch_message(branch_name: &str, removed_worktree: bool) -> String {
+ let lead_in = if removed_worktree {
+ "Removed worktree but kept branch"
+ } else {
+ "Kept branch"
+ };
+ let cmd = suggest_command("remove", &[branch_name], &["-D"]);
+ warning_message(cformat!(
+ "{lead_in} <bold>{branch_name}</> (moved during deletion); inspect commits, then run <bold>{cmd}</> if safe"
+ ))
+ .to_string()
+}
+
/// Handle the result of a branch deletion attempt.
///
/// Converts a deletion attempt into structured display data:
-/// - `NotDeleted`: We checked and chose not to delete (not integrated)
+/// - `NotDeleted`: We checked and chose not to delete (not integrated) — sets
+/// `show_unmerged_hint`.
+/// - `RetainedRaced`: integration check passed but the atomic CAS delete was
+/// refused because the ref moved (a hook or concurrent process advanced it).
+/// Callers surface this with [`retained_raced_branch_message`], not the
+/// unmerged hint, so it is *not* folded into `show_unmerged_hint`.
/// - `Err(e)`: Git command failed - show warning with actual error
fn handle_branch_deletion_result(
result: anyhow::Result<BranchDeletionResult>,
@@ -637,7 +778,9 @@ fn flag_note(
}
match outcome {
- BranchDeletionOutcome::NotDeleted => FlagNote::empty(),
+ BranchDeletionOutcome::NotDeleted | BranchDeletionOutcome::RetainedRaced => {
+ FlagNote::empty()
+ }
BranchDeletionOutcome::ForceDeleted => FlagNote::text_only(" (--force-delete)"),
BranchDeletionOutcome::Integrated(reason) => {
let Some(target) = target_branch else {
@@ -956,19 +1099,37 @@ fn handle_branch_only_output(
let check_target = target_branch.unwrap_or("HEAD");
- // Decide outcome from pre-computed integration (computed in prepare_worktree_removal).
- let outcome = if deletion_mode.is_force() {
- Some(BranchDeletionOutcome::ForceDeleted)
- } else {
- integration_reason.map(BranchDeletionOutcome::Integrated)
- };
-
- let deletion = if let Some(outcome) = outcome {
+ // Force-delete bypasses CAS entirely — `git branch -D` is the user's
+ // explicit override. For safe-delete with a pre-computed integration
+ // reason, re-run `delete_branch_if_safe`: a fresh snapshot lets the
+ // atomic CAS in there catch any tip movement since planning, rather than
+ // trusting the planner's stale view of the ref.
+ let deletion = if let Some(integrated_reason) = integration_reason
+ && !deletion_mode.is_force()
+ {
+ let repo = worktrunk::git::Repository::current()?;
+ let result = repo
+ .capture_refs()
+ .and_then(|snapshot| {
+ delete_branch_if_safe(&repo, &snapshot, branch_name, check_target, false)
+ })
+ .map(|mut r| {
+ // Preserve the planner's recorded reason so a CAS-accepted
+ // delete still reports the original "integrated because X"
+ // explanation. The fresh integration target stays as the
+ // helper computed it.
+ if matches!(r.outcome, BranchDeletionOutcome::Integrated(_)) {
+ r.outcome = BranchDeletionOutcome::Integrated(integrated_reason);
+ }
+ r
+ });
+ handle_branch_deletion_result(result, branch_name)?
+ } else if deletion_mode.is_force() {
let repo = worktrunk::git::Repository::current()?;
let result = repo.run_command(&["branch", "-D", branch_name]);
handle_branch_deletion_result(
result.map(|_| BranchDeletionResult {
- outcome,
+ outcome: BranchDeletionOutcome::ForceDeleted,
integration_target: check_target.to_string(),
}),
branch_name,
@@ -983,9 +1144,17 @@ fn handle_branch_only_output(
}
};
- if matches!(deletion.result.outcome, BranchDeletionOutcome::NotDeleted) {
+ if matches!(
+ deletion.result.outcome,
+ BranchDeletionOutcome::NotDeleted | BranchDeletionOutcome::RetainedRaced
+ ) {
eprintln!("{}", info_message(&branch_info));
- if deletion.show_unmerged_hint {
+ if matches!(
+ deletion.result.outcome,
+ BranchDeletionOutcome::RetainedRaced
+ ) {
+ eprintln!("{}", retained_raced_branch_message(branch_name, false));
+ } else if deletion.show_unmerged_hint {
print_retained_unmerged_branch(branch_name);
}
} else {
@@ -1272,6 +1441,16 @@ impl RemovalDisplayInfo {
return Ok(());
}
+ // A raced retention isn't "unmerged" — the branch was integrated but
+ // its tip moved during the delete. Surface the dedicated message
+ // (inspect commits, then force-delete if safe) rather than falling
+ // through to the generic unmerged hint, whose bare `-D` would drop the
+ // racing commits.
+ if matches!(self.outcome, BranchDeletionOutcome::RetainedRaced) {
+ eprintln!("{}", retained_raced_branch_message(branch_name, true));
+ return Ok(());
+ }
+
if deletion_mode.should_keep() {
if let Some(reason) = pre_computed_integration.as_ref() {
// User kept an integrated branch - show integration info
@@ -1504,6 +1683,9 @@ fn handle_detached_removed_worktree_output(
target_branch: ctx.target_branch,
force_worktree: ctx.force_worktree,
changed_directory: ctx.changed_directory,
+ // No branch → field is unused, but pick the silent-on-NotDeleted
+ // default in case the detached HEAD ever gains a branch name.
+ planner_expected_retention: true,
},
"detached",
ctx.background_fallback_mode,
@@ -1601,6 +1783,13 @@ fn handle_named_removed_worktree_background(
display_info.print_hints(branch_name, ctx.deletion_mode, safety.integration_reason)?;
print_switch_message_if_changed(ctx.changed_directory, ctx.main_path)?;
+ // Planner predicted retention when the user asked to keep, or when the
+ // integration check before this returned no reason — `print_hints` has
+ // already explained either case. A `NotDeleted` outcome surprises only if
+ // the planner predicted deletion.
+ let planner_expected_retention =
+ ctx.deletion_mode.should_keep() || safety.integration_reason.is_none();
+
spawn_background_removal(
repo,
ctx.main_path,
@@ -1611,6 +1800,7 @@ fn handle_named_removed_worktree_background(
target_branch: safety.target_branch(),
force_worktree: ctx.force_worktree,
changed_directory: ctx.changed_directory,
+ planner_expected_retention,
},
branch_name,
ctx.background_fallback_mode,
@@ -1851,6 +2041,83 @@ mod tests {
use super::*;
use insta::assert_snapshot;
+ /// Exercises each arm of [`warn_if_branch_retained`] for coverage and
+ /// to pin the suppression rule. Output goes to stderr and isn't captured
+ /// here — the assertion is that the call doesn't panic on any arm.
+ /// User-visible message shapes are exercised by the integration tests
+ /// (e.g. `test_merge_pre_remove_new_commit_keeps_branch`).
+ #[test]
+ fn warn_if_branch_retained_arms() {
+ let ok = |outcome| {
+ Ok::<_, anyhow::Error>(BranchDeletionResult {
+ outcome,
+ integration_target: "main".to_string(),
+ })
+ };
+
+ // NotDeleted + planner did NOT expect retention → warn (surprise race)
+ warn_if_branch_retained("feature", &ok(BranchDeletionOutcome::NotDeleted), false);
+
+ // NotDeleted + planner DID expect retention → silent (print_hints
+ // already explained)
+ warn_if_branch_retained("feature", &ok(BranchDeletionOutcome::NotDeleted), true);
+
+ // RetainedRaced → always surface, regardless of planner prediction
+ warn_if_branch_retained("feature", &ok(BranchDeletionOutcome::RetainedRaced), false);
+ warn_if_branch_retained("feature", &ok(BranchDeletionOutcome::RetainedRaced), true);
+
+ // Success arms → silent
+ warn_if_branch_retained("feature", &ok(BranchDeletionOutcome::ForceDeleted), false);
+ warn_if_branch_retained(
+ "feature",
+ &ok(BranchDeletionOutcome::Integrated(
+ IntegrationReason::SameCommit,
+ )),
+ false,
+ );
+
+ // Err arm → tracing::warn! only, no stderr message
+ warn_if_branch_retained(
+ "feature",
+ &Err(anyhow::anyhow!("simulated git failure")),
+ false,
+ );
+ }
+
+ /// The shared raced-retention message varies its lead-in with
+ /// `removed_worktree` and always suggests the canonical `-D` recovery.
+ #[test]
+ fn retained_raced_branch_message_lead_in_varies() {
+ let removed = retained_raced_branch_message("feature", true);
+ assert!(removed.contains("Removed worktree but kept branch"));
+ assert!(removed.contains("moved during deletion"));
+ assert!(removed.contains("wt remove -D feature"));
+
+ let branch_only = retained_raced_branch_message("feature", false);
+ assert!(branch_only.contains("Kept branch"));
+ assert!(!branch_only.contains("Removed worktree"));
+ assert!(branch_only.contains("wt remove -D feature"));
+ }
+
+ #[test]
+ fn build_remove_command_with_tail_appends_only_when_present() {
+ let path = Path::new("/tmp/wt");
+ let bare = build_remove_command_with_tail(path, false, false, None);
+ // No tail → the command is exactly the bare worktree removal.
+ assert!(!bare.contains("&&"));
+ let tailed = build_remove_command_with_tail(
+ path,
+ false,
+ false,
+ Some("git update-ref -d refs/heads/x deadbeef"),
+ );
+ // A tail is chained with `&&` so it runs only after a successful removal.
+ assert_eq!(
+ tailed,
+ format!("{bare} && git update-ref -d refs/heads/x deadbeef")
+ );
+ }
+
#[test]
fn test_format_switch_message() {
let path = PathBuf::from("/tmp/test");
diff --git a/tests/integration_tests/step_prune.rs b/tests/integration_tests/step_prune.rs
index 1e587a8e1..9d603e12d 100644
--- a/tests/integration_tests/step_prune.rs
+++ b/tests/integration_tests/step_prune.rs
@@ -1481,13 +1481,21 @@ fn write_delaying_git_wrapper(dir: &std::path::Path, real_git: &std::path::Path)
use std::os::unix::fs::PermissionsExt;
let real_git = shell_escape::unix::escape(real_git.to_string_lossy());
- // Match both `branch -d` and `branch -D` — `delete_branch_if_safe` uses
- // `-D` for branches it has classified as integrated.
+ // Match all three deletion shapes:
+ // - `branch -d <branch>` (force-delete via `git branch -D` from
+ // `delete_branch_if_safe`'s force path was previously also covered
+ // by the `-D` alternative)
+ // - `branch -D <branch>` (force path)
+ // - `update-ref -d refs/heads/<branch> <expected-sha>` (the CAS path
+ // `delete_branch_if_safe` now takes when the branch is integrated)
let script = format!(
r#"#!/bin/sh
if [ "$1" = "branch" ] && {{ [ "$2" = "-d" ] || [ "$2" = "-D" ]; }} && [ "$3" = "$WT_PRUNE_DELAY_BRANCH" ]; then
: > "$WT_PRUNE_BRANCH_DELETE_STARTED"
sleep 2
+elif [ "$1" = "update-ref" ] && [ "$2" = "-d" ] && [ "$3" = "refs/heads/$WT_PRUNE_DELAY_BRANCH" ]; then
+ : > "$WT_PRUNE_BRANCH_DELETE_STARTED"
+ sleep 2
fi
exec {real_git} "$@"
"#