feat(status): show the worktree holding each branch

`git stack status` gave no signal that a branch was checked out in another
git worktree; the branch rendered exactly like any other local branch, and
the conflict only surfaced when a checkout was attempted and git refused.

Enumerate worktrees once per render and print the holding worktree's path
last on the branch line, in square brackets, in a pale green distinct from
the diff-stat green. Every worktree is badged, including the current and
main ones, so a single-worktree repo now shows its checked-out branch's
repo root. Detached, prunable, and bare worktrees contribute nothing, and a
failed enumeration renders the tree with no badges and no error.

`worktree_holding_branch` now consumes the same shared map, so one
enumeration path and one set of parse rules serve both the checkout guard
and the renderer. The TUI renders the same badge in the same position;
splitting `branch_line` out of `render_branch_item` makes its spans
testable.

Author: wbbradley

src/git.rs

@@ -1,4 +1,5 @@
 use std::{
+    collections::HashMap,
     process::{Command, ExitStatus},
     time::Instant,
 };
@@ -464,6 +465,33 @@ fn canonicalize_worktree_path(path: &str) -> String {
         .unwrap_or_else(|| path.trim_end_matches('/').to_string())
 }
 
+/// Map short branch name to the git-reported path of the worktree holding it.
+///
+/// Entries with no `branch` line (detached HEAD, bare repo) contribute nothing:
+/// no branch is checked out there. Prunable worktrees are skipped because their
+/// directory is gone, so reporting the path would point at nothing. The current
+/// worktree is *kept* — callers that only care about *other* worktrees filter it
+/// out themselves.
+fn worktree_map_from_entries(entries: Vec<WorktreeEntry>) -> HashMap<String, String> {
+    entries
+        .into_iter()
+        .filter(|entry| !entry.prunable)
+        .filter_map(|entry| entry.branch.map(|branch| (branch, entry.path)))
+        .collect()
+}
+
+/// Enumerate every worktree once, mapping checked-out branch to worktree path.
+///
+/// Returns an empty map when enumeration fails for any reason: callers use this
+/// for display and for diagnostic pre-checks, neither of which may fail because
+/// `git worktree list` did.
+pub(crate) fn worktree_paths_by_branch() -> HashMap<String, String> {
+    match run_git(&["worktree", "list", "--porcelain"]) {
+        Ok(out) => worktree_map_from_entries(parse_worktree_list(&out.stdout)),
+        Err(_) => HashMap::new(),
+    }
+}
+
 /// If `branch` is checked out in a worktree *other than* the current one,
 /// return that worktree's git-reported path. Returns `None` when the branch is
 /// not checked out elsewhere, is checked out in the current worktree (a valid
@@ -473,21 +501,12 @@ fn canonicalize_worktree_path(path: &str) -> String {
 /// never block a normal checkout.
 fn worktree_holding_branch(git_repo: &GitRepo, branch: &str) -> Option<String> {
     let current_root = canonicalize_worktree_path(&git_repo.root().ok()?);
-    let out = run_git(&["worktree", "list", "--porcelain"]).ok()?;
-    for entry in parse_worktree_list(&out.stdout) {
-        if entry.branch.as_deref() != Some(branch) {
-            continue;
-        }
-        if entry.prunable {
-            return None;
-        }
-        if canonicalize_worktree_path(&entry.path) == current_root {
-            // Already on this branch in the current worktree — valid no-op.
-            return None;
-        }
-        return Some(entry.path);
+    let path = worktree_paths_by_branch().remove(branch)?;
+    if canonicalize_worktree_path(&path) == current_root {
+        // Already on this branch in the current worktree — valid no-op.
+        return None;
     }
-    None
+    Some(path)
 }
 
 /// Check out an existing tracked branch, first explaining the common failure
@@ -777,4 +796,60 @@ mod tests {
     fn parse_worktree_list_empty_input() {
         assert!(parse_worktree_list("").is_empty());
     }
+
+    #[test]
+    fn worktree_map_keeps_branch_worktrees_and_drops_the_rest() {
+        // Main worktree on `main`, a linked worktree on `feature`, a detached
+        // worktree, and a stale worktree that still names `abandoned`.
+        let output = "worktree /repo\n\
+            HEAD 1111111111111111111111111111111111111111\n\
+            branch refs/heads/main\n\
+            \n\
+            worktree /wt/feature-wt\n\
+            HEAD 2222222222222222222222222222222222222222\n\
+            branch refs/heads/feature\n\
+            \n\
+            worktree /wt/detached-wt\n\
+            HEAD 3333333333333333333333333333333333333333\n\
+            detached\n\
+            \n\
+            worktree /gone/abandoned-wt\n\
+            HEAD 4444444444444444444444444444444444444444\n\
+            branch refs/heads/abandoned\n\
+            prunable gitdir file points to non-existent location\n";
+        let map = worktree_map_from_entries(parse_worktree_list(output));
+
+        assert_eq!(map.len(), 2);
+        assert_eq!(map.get("main").map(String::as_str), Some("/repo"));
+        assert_eq!(
+            map.get("feature").map(String::as_str),
+            Some("/wt/feature-wt")
+        );
+        // A detached worktree has no branch to attribute the path to.
+        assert!(!map.values().any(|p| p == "/wt/detached-wt"));
+        // A prunable worktree's directory is gone; printing its path is worse
+        // than printing nothing.
+        assert!(!map.contains_key("abandoned"));
+    }
+
+    #[test]
+    fn worktree_map_includes_the_lone_worktree() {
+        // No worktree-count gate: a repo with only its main worktree still maps
+        // that worktree's checked-out branch.
+        let output = "worktree /repo\n\
+            HEAD 1111111111111111111111111111111111111111\n\
+            branch refs/heads/main\n";
+        let map = worktree_map_from_entries(parse_worktree_list(output));
+
+        assert_eq!(map.len(), 1);
+        assert_eq!(map.get("main").map(String::as_str), Some("/repo"));
+    }
+
+    #[test]
+    fn worktree_map_empty_for_bare_repo() {
+        // A bare repo emits `bare` and no branch line.
+        let output = "worktree /repo.git\n\
+            bare\n";
+        assert!(worktree_map_from_entries(parse_worktree_list(output)).is_empty());
+    }
 }

src/render/cli.rs

@@ -25,6 +25,30 @@ fn apply_color(s: &str, color: ThemeColor) -> colored::ColoredString {
     s.truecolor(r, g, b)
 }
 
+/// Replace a leading `$HOME` with `~`, leaving any other path unchanged.
+pub fn abbreviate_home(path: &str) -> String {
+    abbreviate_with_home(path, std::env::var("HOME").ok().as_deref())
+}
+
+/// Core of [`abbreviate_home`], with `home` passed explicitly so it is testable
+/// without mutating the process environment. Only matches on a path-segment
+/// boundary, so `/home/willy` is not rewritten under `HOME=/home/will`.
+fn abbreviate_with_home(path: &str, home: Option<&str>) -> String {
+    let Some(home) = home.map(|h| h.trim_end_matches('/')) else {
+        return path.to_string();
+    };
+    if home.is_empty() {
+        return path.to_string();
+    }
+    if path == home {
+        return "~".to_string();
+    }
+    match path.strip_prefix(home) {
+        Some(rest) if rest.starts_with('/') => format!("~{rest}"),
+        _ => path.to_string(),
+    }
+}
+
 /// Render the tree to the CLI.
 pub fn render_cli(tree: &RenderableTree, verbose: bool) {
     for branch in &tree.branches {
@@ -110,10 +134,36 @@ fn render_branch(branch: &RenderableBranch, verbose: bool) {
         })
         .unwrap_or_default();
 
+    // Holding worktree. Placed last on the line by both renderers below.
+    let worktree = branch
+        .worktree_path
+        .as_deref()
+        .map(|path| {
+            format!(
+                " [{}]",
+                apply_color(&abbreviate_home(path), theme::WORKTREE.apply_dim(dim))
+            )
+        })
+        .unwrap_or_default();
+
     if verbose {
-        render_verbose_line(branch, &branch_name, &diff_stats, &local_status, dim);
+        render_verbose_line(
+            branch,
+            &branch_name,
+            &diff_stats,
+            &local_status,
+            &worktree,
+            dim,
+        );
     } else {
-        render_simple_line(branch, &branch_name, &diff_stats, &local_status, dim);
+        render_simple_line(
+            branch,
+            &branch_name,
+            &diff_stats,
+            &local_status,
+            &worktree,
+            dim,
+        );
     }
 }
 
@@ -122,6 +172,7 @@ fn render_simple_line(
     branch_name: &colored::ColoredString,
     diff_stats: &str,
     local_status: &str,
+    worktree: &str,
     dim: f32,
 ) {
     // PR info
@@ -158,18 +209,22 @@ fn render_simple_line(
         })
         .unwrap_or_default();
 
-    println!("{}{}{}{}", branch_name, diff_stats, local_status, pr_info);
+    println!(
+        "{}{}{}{}{}",
+        branch_name, diff_stats, local_status, pr_info, worktree
+    );
 }
 
 fn render_verbose_line(
     branch: &RenderableBranch,
     branch_name: &colored::ColoredString,
     diff_stats: &str,
     local_status: &str,
+    worktree: &str,
     dim: f32,
 ) {
     let Some(ref status) = branch.status else {
-        println!("{}", branch_name);
+        println!("{}{}", branch_name, worktree);
         return;
     };
 
@@ -245,7 +300,7 @@ fn render_verbose_line(
         .unwrap_or_default();
 
     println!(
-        "{}{}{} ({}) {}{}{}{}",
+        "{}{}{} ({}) {}{}{}{}{}",
         branch_name,
         diff_stats,
         local_status,
@@ -254,6 +309,7 @@ fn render_verbose_line(
         upstream_info,
         lkg_info,
         method_info,
+        worktree,
     );
 
     // Note preview
@@ -270,3 +326,51 @@ fn render_verbose_line(
         println!("  {} {}", apply_color("›", theme::TREE), note_display);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::abbreviate_with_home;
+
+    #[test]
+    fn abbreviates_a_path_under_home() {
+        assert_eq!(
+            abbreviate_with_home("/home/will/src/proj", Some("/home/will")),
+            "~/src/proj"
+        );
+        assert_eq!(abbreviate_with_home("/home/will", Some("/home/will")), "~");
+        // A trailing slash on HOME must not leave a doubled separator.
+        assert_eq!(
+            abbreviate_with_home("/home/will/src", Some("/home/will/")),
+            "~/src"
+        );
+    }
+
+    #[test]
+    fn passes_through_a_path_outside_home() {
+        assert_eq!(
+            abbreviate_with_home("/var/tmp/feature-wt", Some("/home/will")),
+            "/var/tmp/feature-wt"
+        );
+    }
+
+    #[test]
+    fn passes_through_when_home_is_unset_or_empty() {
+        assert_eq!(
+            abbreviate_with_home("/home/will/src", None),
+            "/home/will/src"
+        );
+        assert_eq!(
+            abbreviate_with_home("/home/will/src", Some("")),
+            "/home/will/src"
+        );
+    }
+
+    #[test]
+    fn does_not_match_a_partial_path_segment() {
+        // `/home/willy` is a different user than `HOME=/home/will`.
+        assert_eq!(
+            abbreviate_with_home("/home/willy/src", Some("/home/will")),
+            "/home/willy/src"
+        );
+    }
+}

src/render/colors.rs

@@ -37,6 +37,10 @@ pub mod theme {
     pub const UPSTREAM: ThemeColor = ThemeColor(88, 88, 88);
     pub const STACKED_ON: ThemeColor = ThemeColor(90, 120, 87);
     pub const BLUE: ThemeColor = ThemeColor(131, 165, 152);
+    /// Worktree paths. Deliberately paler than `GREEN` (which already marks
+    /// descendant branch names, `+additions`, and staged counts) so a diff-stat
+    /// badge and a worktree path don't read as the same token.
+    pub const WORKTREE: ThemeColor = ThemeColor(168, 230, 163);
 }
 
 /// Compute a deterministic RGB color from a string using its hash.

src/render/mod.rs

@@ -4,7 +4,7 @@ pub mod cli;
 pub mod colors;
 pub mod tree_data;
 
-pub use cli::render_cli;
+pub use cli::{abbreviate_home, render_cli};
 pub use colors::ThemeColor;
 pub use tree_data::{
     BranchRenderStatus, PrRenderInfo, RenderableBranch, RenderableTree, apply_pr_cache,

src/render/tree_data.rs

@@ -3,7 +3,7 @@
 use std::collections::{HashMap, HashSet};
 
 use crate::{
-    git::get_local_status,
+    git::{get_local_status, worktree_paths_by_branch},
     git2_ops::GitRepo,
     github::{PrDisplayState, PullRequest},
     state::Branch,
@@ -95,6 +95,10 @@ pub struct RenderableBranch {
     pub note_preview: Option<String>,
     /// Verbose details (populated when verbose mode is requested).
     pub verbose: Option<VerboseDetails>,
+    /// Absolute path of the git worktree holding this branch, if any. Stored raw
+    /// as git reports it; renderers abbreviate it so the shortening policy lives
+    /// in one place.
+    pub worktree_path: Option<String>,
     /// Index in the flattened list (for TUI cursor navigation).
     pub index: usize,
 }
@@ -222,6 +226,8 @@ pub fn compute_renderable_tree(
     let hidden =
         compute_hidden_branches(tree, current_branch, authors_filter, pr_authors, show_all);
     let mut diff_cache = DiffStatsCache::new();
+    // One subprocess for the whole walk, regardless of branch count.
+    let worktrees = worktree_paths_by_branch();
 
     flatten_tree(
         git_repo,
@@ -233,6 +239,7 @@ pub fn compute_renderable_tree(
         authors_filter,
         pr_authors,
         &hidden,
+        &worktrees,
         &mut branches,
         &mut current_branch_index,
         &mut diff_cache,
@@ -271,6 +278,7 @@ fn flatten_tree(
     authors_filter: &[String],
     pr_authors: &HashMap<String, String>,
     hidden: &HashSet<String>,
+    worktrees: &HashMap<String, String>,
     result: &mut Vec<RenderableBranch>,
     current_branch_index: &mut Option<usize>,
     cache: &mut DiffStatsCache,
@@ -371,6 +379,7 @@ fn flatten_tree(
             pr_info,
             note_preview,
             verbose: verbose_details,
+            worktree_path: worktrees.get(&branch.name).cloned(),
             index,
         });
     }
@@ -431,6 +440,7 @@ fn flatten_tree(
             authors_filter,
             pr_authors,
             hidden,
+            worktrees,
             result,
             current_branch_index,
             cache,
@@ -741,6 +751,7 @@ mod tests {
             pr_info: None,
             note_preview: None,
             verbose: None,
+            worktree_path: None,
             index,
         }
     }