Worktrunk is a CLI for Git worktree management, designed for parallel AI agent workflows
fix(relocate): skip worktree blocked by an immovable occupant (#3530)
Worktrunk Botcad89eaebbb3
diff --git a/src/commands/relocate.rs b/src/commands/relocate.rsindex c84574462..4a44b03e1 100644--- a/src/commands/relocate.rs+++ b/src/commands/relocate.rs@@ -467,7 +467,28 @@ impl<'a> RelocationExecutor<'a> {made_progress = true;}Some(false) => {- // Target occupied by another pending worktree - wait for it to move+ // Target occupied by another pending worktree. If that+ // occupant is itself blocked it will never vacate, so+ // this worktree can never reach its target either —+ // propagate the block. Leaving it for `break_cycle`+ // would temp-move it and then fail to finalize into the+ // still-occupied path, stranding it in the staging dir.+ if let Some(occupant_idx) = self.blocked_occupant(i) {+ let branch = self.pending[i].branch().to_string();+ let occupant = self.pending[occupant_idx].branch().to_string();+ let msg = cformat!(+ "Skipping <bold>{branch}</> (blocked by <bold>{occupant}</>, which can't be relocated)"+ );+ eprintln!("{}", warning_message(msg));+ self.blocked.insert(i);+ self.skipped_entries.push(SkippedEntry {+ branch,+ reason: "target_blocked",+ });+ made_progress = true;+ }+ // Otherwise the occupant is still pending and may yet+ // move (or forms a cycle `break_cycle` resolves).}None => {// Target unexpectedly blocked (TOCTOU race or same-target conflict)@@ -528,6 +549,29 @@ impl<'a> RelocationExecutor<'a> {.map(|occupant_idx| self.moved.contains(occupant_idx))}+ /// If `idx`'s target is occupied by a worktree we've already classified as+ /// blocked (it will never vacate), return that occupant's index.+ ///+ /// A dependent whose occupant is blocked can never reach its target, so it+ /// must be blocked too rather than handed to `break_cycle`. `break_cycle`+ /// assumes "no progress ⟹ a cycle," temp-moves the dependent into the+ /// staging dir, and `finalize_temp_relocations` then fails moving it into+ /// the still-occupied target — erroring out and stranding the worktree in+ /// staging.+ fn blocked_occupant(&self, idx: usize) -> Option<usize> {+ // The sole caller reaches here from `is_target_empty`'s `Some(false)`+ // arm, which already established the target exists and is a tracked+ // worktree — so no existence guard is needed. If the path were somehow+ // gone, `canonicalize` falls back to the raw path, which won't match a+ // canonical key, and `get` returns `None`.+ let expected = &self.pending[idx].expected_path;+ let canonical = expected.canonicalize().unwrap_or_else(|_| expected.clone());+ self.current_locations+ .get(&canonical)+ .copied()+ .filter(|occupant_idx| self.blocked.contains(occupant_idx))+ }+/// Move a single worktree to its expected path.fn move_worktree(&mut self,diff --git a/tests/integration_tests/step_relocate.rs b/tests/integration_tests/step_relocate.rsindex a3d0df57a..f64099f73 100644--- a/tests/integration_tests/step_relocate.rs+++ b/tests/integration_tests/step_relocate.rs@@ -770,6 +770,164 @@ fn test_relocate_swap(repo: TestRepo) {assert!(path_for_beta.exists(), "beta should be at repo.beta");}+/// A worktree whose target is occupied by a *blocked* worktree must itself be+/// skipped, not temp-moved.+///+/// Regression: `beta` sits at `alpha`'s target, so `alpha` depends on `beta`+/// vacating — but `beta`'s own target is a plain non-worktree file with no+/// `--clobber`, so `beta` is blocked and never moves. Previously the no-progress+/// branch treated `alpha` as a cycle, temp-moved it into the staging dir, and+/// `finalize` then failed moving it into the still-occupied target — erroring+/// out and stranding `alpha` in `.git/wt/staging/relocate/`.+#[rstest]+fn test_relocate_blocked_occupant_skips_dependent(repo: TestRepo) {+ let parent = worktree_parent(&repo);++ // beta occupies alpha's expected path (repo.alpha).+ let path_alpha = parent.join("repo.alpha");+ repo.run_git(&[+ "worktree",+ "add",+ "-b",+ "beta",+ path_alpha.to_str().unwrap(),+ ]);++ // alpha lives at a non-standard location and wants repo.alpha.+ let wrong_alpha = parent.join("wrong-alpha");+ repo.run_git(&[+ "worktree",+ "add",+ "-b",+ "alpha",+ wrong_alpha.to_str().unwrap(),+ ]);++ // Block beta's target (repo.beta) with a plain, non-worktree directory.+ let path_beta = parent.join("repo.beta");+ fs::create_dir_all(&path_beta).unwrap();+ fs::write(path_beta.join("blocker.txt"), "blocker").unwrap();++ // Both are skipped; the command must succeed and strand nothing.+ assert_cmd_snapshot!(make_snapshot_cmd(+ &repo,+ "step",+ &["relocate", "alpha", "beta"],+ None+ ));++ // alpha stays at its original location (not stranded in staging).+ assert!(+ wrong_alpha.exists(),+ "alpha should remain at its original location: {}",+ wrong_alpha.display()+ );+ // beta stays where it was (still occupying repo.alpha).+ assert!(path_alpha.exists(), "beta should remain at repo.alpha");+ // Nothing left behind in the staging dir.+ let stranded = repo.root_path().join(".git/wt/staging/relocate/alpha");+ assert!(+ !stranded.exists(),+ "alpha must not be stranded in the staging dir: {}",+ stranded.display()+ );+}++/// A blocked occupant must propagate transitively down a chain of dependents,+/// across multiple resolution passes.+///+/// Extends `test_relocate_blocked_occupant_skips_dependent` to a 3-level chain+/// (`alpha → beta → gamma-blocked`) that specifically exercises the loop's+/// `made_progress` re-drive. `gamma`'s target is a plain non-worktree directory+/// (no `--clobber`), so `gamma` is blocked at construction; `beta` occupies+/// `gamma`'s dependency (sits at repo.beta) and `alpha` occupies `beta`'s (sits+/// at repo.alpha), so the block can only reach `alpha` one pass after it reaches+/// `beta`.+///+/// The re-drive is only load-bearing when a dependent is *iterated before* its+/// occupant within a pass. Worktrees are processed in `git worktree list` order+/// (git sorts linked worktrees by registration id ≈ path basename), independent+/// of the argument order — so `alpha` is parked at `aaa-alpha`, whose basename+/// sorts before `beta`'s `repo.alpha`. That makes pass 1 visit `alpha` while+/// `beta` is still pending (no block yet → `alpha` stays pending), then block+/// `beta` (occupant `gamma` already blocked). Only the `made_progress` re-drive+/// runs a pass 2 that sees `beta` blocked and blocks `alpha` in turn. Drop the+/// re-drive and pass 1 falls straight into `break_cycle`, which temp-moves the+/// still-pending `alpha` and `finalize` then misplaces it into the occupied+/// `repo.alpha` — the exact bug this guards. (Parking `alpha` at a path that+/// sorts *after* `repo.alpha` collapses the chain into a single pass and no+/// longer tests the re-drive; see the 2-level test.)+#[rstest]+fn test_relocate_blocked_occupant_skips_chain(repo: TestRepo) {+ let parent = worktree_parent(&repo);++ // alpha lives at aaa-alpha (basename sorts before repo.alpha, so alpha is+ // iterated before its occupant beta) and wants repo.alpha.+ let wrong_alpha = parent.join("aaa-alpha");+ repo.run_git(&[+ "worktree",+ "add",+ "-b",+ "alpha",+ wrong_alpha.to_str().unwrap(),+ ]);++ // beta occupies alpha's expected path (repo.alpha) and wants repo.beta.+ let path_alpha = parent.join("repo.alpha");+ repo.run_git(&[+ "worktree",+ "add",+ "-b",+ "beta",+ path_alpha.to_str().unwrap(),+ ]);++ // gamma occupies beta's expected path (repo.beta) and wants repo.gamma.+ let path_beta = parent.join("repo.beta");+ repo.run_git(&[+ "worktree",+ "add",+ "-b",+ "gamma",+ path_beta.to_str().unwrap(),+ ]);++ // Block gamma's target (repo.gamma) with a plain, non-worktree directory.+ let path_gamma = parent.join("repo.gamma");+ fs::create_dir_all(&path_gamma).unwrap();+ fs::write(path_gamma.join("blocker.txt"), "blocker").unwrap();++ // All three are skipped; the command must succeed and strand nothing.+ assert_cmd_snapshot!(make_snapshot_cmd(+ &repo,+ "step",+ &["relocate", "alpha", "beta", "gamma"],+ None+ ));++ // Every worktree stays put — none stranded in staging or misplaced into an+ // occupied target.+ assert!(+ wrong_alpha.exists(),+ "alpha should remain at its original location: {}",+ wrong_alpha.display()+ );+ assert!(path_alpha.exists(), "beta should remain at repo.alpha");+ assert!(path_beta.exists(), "gamma should remain at repo.beta");+ let stranded = repo.root_path().join(".git/wt/staging/relocate/alpha");+ assert!(+ !stranded.exists(),+ "alpha must not be stranded in the staging dir: {}",+ stranded.display()+ );+ let misplaced = path_alpha.join("alpha");+ assert!(+ !misplaced.exists(),+ "alpha must not be misplaced inside beta's worktree: {}",+ misplaced.display()+ );+}+/// Test relocating multiple worktrees shows compact output#[rstest]fn test_relocate_multiple(repo: TestRepo) {diff --git a/tests/snapshots/integration__integration_tests__step_relocate__relocate_blocked_occupant_skips_chain.snap b/tests/snapshots/integration__integration_tests__step_relocate__relocate_blocked_occupant_skips_chain.snapnew file mode 100644index 000000000..5730dfa39--- /dev/null+++ b/tests/snapshots/integration__integration_tests__step_relocate__relocate_blocked_occupant_skips_chain.snap@@ -0,0 +1,59 @@+---+source: tests/integration_tests/step_relocate.rs+info:+ program: wt+ args:+ - step+ - relocate+ - alpha+ - beta+ - gamma+ env:+ APPDATA: "[TEST_CONFIG_HOME]"+ CLAUDE_CONFIG_DIR: "[TEST_CLAUDE_CONFIG]"+ CLICOLOR_FORCE: "1"+ COLUMNS: "500"+ GIT_AUTHOR_DATE: "2025-01-01T00:00:00Z"+ GIT_COMMITTER_DATE: "2025-01-01T00:00:00Z"+ GIT_CONFIG_GLOBAL: "[TEST_GIT_CONFIG]"+ GIT_CONFIG_SYSTEM: /dev/null+ GIT_TERMINAL_PROMPT: "0"+ HOME: "[TEST_HOME]"+ LANG: C+ LC_ALL: C+ LLVM_PROFILE_FILE: "[LLVM_PROFILE_FILE]"+ MOCK_CONFIG_DIR: "[MOCK_CONFIG_DIR]"+ OPENCODE_CONFIG_DIR: "[TEST_OPENCODE_CONFIG]"+ PATH: "[PATH]"+ TERM: alacritty+ USERPROFILE: "[TEST_HOME]"+ WORKTRUNK_APPROVALS_PATH: "[TEST_APPROVALS]"+ WORKTRUNK_CONFIG_PATH: "[TEST_CONFIG]"+ WORKTRUNK_SYSTEM_CONFIG_PATH: "[TEST_SYSTEM_CONFIG]"+ WORKTRUNK_TEST_BASH_INSTALLED: "0"+ WORKTRUNK_TEST_CLAUDE_INSTALLED: "0"+ WORKTRUNK_TEST_CODEX_INSTALLED: "0"+ WORKTRUNK_TEST_DELAYED_STREAM_MS: "-1"+ WORKTRUNK_TEST_EPOCH: "1735776000"+ WORKTRUNK_TEST_FISH_INSTALLED: "0"+ WORKTRUNK_TEST_GEMINI_INSTALLED: "0"+ WORKTRUNK_TEST_NUSHELL_ENV: "0"+ WORKTRUNK_TEST_OPENCODE_INSTALLED: "0"+ WORKTRUNK_TEST_PARENT_SHELL: ""+ WORKTRUNK_TEST_POWERSHELL_ENV: "0"+ WORKTRUNK_TEST_POWERSHELL_INSTALLED: "0"+ WORKTRUNK_TEST_SKIP_URL_HEALTH_CHECK: "1"+ WORKTRUNK_TEST_ZSH_INSTALLED: "0"+ XDG_CONFIG_HOME: "[TEST_CONFIG_HOME]"+---+success: true+exit_code: 0+----- stdout -----++----- stderr -----+[33m▲[39m [33mSkipping [1mgamma[22m (target blocked: _REPO_.gamma)[39m+[2m↳[22m [2mTo backup blocking paths, use [4m--clobber[24m[22m+[33m▲[39m [33mSkipping [1mbeta[22m (blocked by [1mgamma[22m, which can't be relocated)[39m+[33m▲[39m [33mSkipping [1malpha[22m (blocked by [1mbeta[22m, which can't be relocated)[39m++[2m○[22m Relocated 0 worktrees, skipped 3 worktreesdiff --git a/tests/snapshots/integration__integration_tests__step_relocate__relocate_blocked_occupant_skips_dependent.snap b/tests/snapshots/integration__integration_tests__step_relocate__relocate_blocked_occupant_skips_dependent.snapnew file mode 100644index 000000000..7b69c6cea--- /dev/null+++ b/tests/snapshots/integration__integration_tests__step_relocate__relocate_blocked_occupant_skips_dependent.snap@@ -0,0 +1,57 @@+---+source: tests/integration_tests/step_relocate.rs+info:+ program: wt+ args:+ - step+ - relocate+ - alpha+ - beta+ env:+ APPDATA: "[TEST_CONFIG_HOME]"+ CLAUDE_CONFIG_DIR: "[TEST_CLAUDE_CONFIG]"+ CLICOLOR_FORCE: "1"+ COLUMNS: "500"+ GIT_AUTHOR_DATE: "2025-01-01T00:00:00Z"+ GIT_COMMITTER_DATE: "2025-01-01T00:00:00Z"+ GIT_CONFIG_GLOBAL: "[TEST_GIT_CONFIG]"+ GIT_CONFIG_SYSTEM: /dev/null+ GIT_TERMINAL_PROMPT: "0"+ HOME: "[TEST_HOME]"+ LANG: C+ LC_ALL: C+ LLVM_PROFILE_FILE: "[LLVM_PROFILE_FILE]"+ MOCK_CONFIG_DIR: "[MOCK_CONFIG_DIR]"+ OPENCODE_CONFIG_DIR: "[TEST_OPENCODE_CONFIG]"+ PATH: "[PATH]"+ TERM: alacritty+ USERPROFILE: "[TEST_HOME]"+ WORKTRUNK_APPROVALS_PATH: "[TEST_APPROVALS]"+ WORKTRUNK_CONFIG_PATH: "[TEST_CONFIG]"+ WORKTRUNK_SYSTEM_CONFIG_PATH: "[TEST_SYSTEM_CONFIG]"+ WORKTRUNK_TEST_BASH_INSTALLED: "0"+ WORKTRUNK_TEST_CLAUDE_INSTALLED: "0"+ WORKTRUNK_TEST_CODEX_INSTALLED: "0"+ WORKTRUNK_TEST_DELAYED_STREAM_MS: "-1"+ WORKTRUNK_TEST_EPOCH: "1735776000"+ WORKTRUNK_TEST_FISH_INSTALLED: "0"+ WORKTRUNK_TEST_GEMINI_INSTALLED: "0"+ WORKTRUNK_TEST_NUSHELL_ENV: "0"+ WORKTRUNK_TEST_OPENCODE_INSTALLED: "0"+ WORKTRUNK_TEST_PARENT_SHELL: ""+ WORKTRUNK_TEST_POWERSHELL_ENV: "0"+ WORKTRUNK_TEST_POWERSHELL_INSTALLED: "0"+ WORKTRUNK_TEST_SKIP_URL_HEALTH_CHECK: "1"+ WORKTRUNK_TEST_ZSH_INSTALLED: "0"+ XDG_CONFIG_HOME: "[TEST_CONFIG_HOME]"+---+success: true+exit_code: 0+----- stdout -----++----- stderr -----+[33m▲[39m [33mSkipping [1mbeta[22m (target blocked: _REPO_.beta)[39m+[2m↳[22m [2mTo backup blocking paths, use [4m--clobber[24m[22m+[33m▲[39m [33mSkipping [1malpha[22m (blocked by [1mbeta[22m, which can't be relocated)[39m++[2m○[22m Relocated 0 worktrees, skipped 2 worktrees