Skip to content

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

Add MainState::Empty to distinguish clean same-commit branches (#185)

Maximilian Roos63fb7106f936
diff --git a/docs/content/list.md b/docs/content/list.md
index cb577b21c..55572e32b 100644
--- a/docs/content/list.md
+++ b/docs/content/list.md
@@ -119,7 +119,8 @@ The Status column has multiple subcolumns. Within each, only the first matching
| | `⊞` | Locked worktree |
| Main | `^` | Is the main branch |
| | `✗` | Would conflict if merged to main |
-| | `_` | Same commit as main |
+| | `_` | Same commit as main, clean |
+| | `–` | Same commit as main, uncommitted changes |
| | `⊂` | [Content integrated](@/remove.md#branch-cleanup) |
| | `↕` | Diverged from main |
| | `↑` | Ahead of main |
@@ -129,7 +130,7 @@ The Status column has multiple subcolumns. Within each, only the first matching
| | `⇡` | Ahead of remote |
| | `⇣` | Behind remote |
-Rows are dimmed when the branch [content is already in main](@/remove.md#branch-cleanup) (`_` same commit or `⊂` content integrated).
+Rows are dimmed when [safe to delete](@/remove.md#branch-cleanup) (`_` same commit with clean working tree or `⊂` content integrated).
## JSON output
@@ -149,7 +150,7 @@ wt list --format=json | jq '.[] | select(.is_current)'
wt list --format=json | jq '.[] | select(.main.ahead > 0)'
# Integrated branches (ready to clean up)
-wt list --format=json | jq '.[] | select(.main_state == "integrated" or .main_state == "same_commit")'
+wt list --format=json | jq '.[] | select(.main_state == "integrated" or .main_state == "empty")'
```
**Fields:**
@@ -161,7 +162,7 @@ wt list --format=json | jq '.[] | select(.main_state == "integrated" or .main_st
| `kind` | `"worktree"` or `"branch"` |
| `commit` | `{sha, short_sha, message, timestamp}` |
| `working_tree` | `{staged, modified, untracked, renamed, deleted, diff, diff_vs_main}` |
-| `main_state` | `"is_main"` `"would_conflict"` `"same_commit"` `"integrated"` `"diverged"` `"ahead"` `"behind"` |
+| `main_state` | `"is_main"` `"would_conflict"` `"empty"` `"same_commit"` `"integrated"` `"diverged"` `"ahead"` `"behind"` |
| `integration_reason` | `"ancestor"` `"trees_match"` `"no_added_changes"` `"merge_adds_nothing"` (when `main_state == "integrated"`) |
| `operation_state` | `"conflicts"` `"rebase"` `"merge"` (absent when no operation in progress) |
| `main` | `{ahead, behind, diff}` (absent when `is_main`) |
diff --git a/src/cli.rs b/src/cli.rs
index 7c11408b2..8ae827e07 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -1752,7 +1752,8 @@ The Status column has multiple subcolumns. Within each, only the first matching
| | `⊞` | Locked worktree |
| Main | `^` | Is the main branch |
| | `✗` | Would conflict if merged to main |
-| | `_` | Same commit as main |
+| | `_` | Same commit as main, clean |
+| | `–` | Same commit as main, uncommitted changes |
| | `⊂` | [Content integrated](@/remove.md#branch-cleanup) |
| | `↕` | Diverged from main |
| | `↑` | Ahead of main |
@@ -1762,7 +1763,7 @@ The Status column has multiple subcolumns. Within each, only the first matching
| | `⇡` | Ahead of remote |
| | `⇣` | Behind remote |
-Rows are dimmed when the branch [content is already in main](@/remove.md#branch-cleanup) (`_` same commit or `⊂` content integrated).
+Rows are dimmed when [safe to delete](@/remove.md#branch-cleanup) (`_` same commit with clean working tree or `⊂` content integrated).
## JSON output
@@ -1782,7 +1783,7 @@ wt list --format=json | jq '.[] | select(.is_current)'
wt list --format=json | jq '.[] | select(.main.ahead > 0)'
# Integrated branches (ready to clean up)
-wt list --format=json | jq '.[] | select(.main_state == "integrated" or .main_state == "same_commit")'
+wt list --format=json | jq '.[] | select(.main_state == "integrated" or .main_state == "empty")'
```
**Fields:**
@@ -1794,7 +1795,7 @@ wt list --format=json | jq '.[] | select(.main_state == "integrated" or .main_st
| `kind` | `"worktree"` or `"branch"` |
| `commit` | `{sha, short_sha, message, timestamp}` |
| `working_tree` | `{staged, modified, untracked, renamed, deleted, diff, diff_vs_main}` |
-| `main_state` | `"is_main"` `"would_conflict"` `"same_commit"` `"integrated"` `"diverged"` `"ahead"` `"behind"` |
+| `main_state` | `"is_main"` `"would_conflict"` `"empty"` `"same_commit"` `"integrated"` `"diverged"` `"ahead"` `"behind"` |
| `integration_reason` | `"ancestor"` `"trees_match"` `"no_added_changes"` `"merge_adds_nothing"` (when `main_state == "integrated"`) |
| `operation_state` | `"conflicts"` `"rebase"` `"merge"` (absent when no operation in progress) |
| `main` | `{ahead, behind, diff}` (absent when `is_main`) |
diff --git a/src/commands/list/model.rs b/src/commands/list/model.rs
index 5d64fed4c..9485eeaad 100644
--- a/src/commands/list/model.rs
+++ b/src/commands/list/model.rs
@@ -335,9 +335,10 @@ impl ListItem {
pub(crate) fn is_potentially_removable(&self) -> Option<bool> {
// Use already-computed status_symbols if available
let main_state = self.status_symbols.as_ref()?.main_state;
+ // SameCommit excluded: has uncommitted work that would be lost
Some(matches!(
main_state,
- MainState::SameCommit | MainState::Integrated(_)
+ MainState::Empty | MainState::Integrated(_)
))
}
@@ -484,8 +485,8 @@ impl ListItem {
OperationState::None
};
- // Determine integration state (for non-main worktrees)
- let integration = determine_integration_state(
+ // Check if content is integrated into main (safe to delete)
+ let integration = check_integration_state(
data.is_main,
default_branch,
self.is_ancestor,
@@ -497,11 +498,21 @@ impl ListItem {
&data.working_tree_diff_with_main,
);
+ // Separately detect SameCommit: same commit as main but with uncommitted work
+ // This is NOT an integration state (has work that would be lost on delete)
+ let is_same_commit_dirty = self.is_ancestor == Some(true)
+ && self.counts.as_ref().is_some_and(|c| c.behind == 0)
+ && data
+ .working_tree_diff
+ .as_ref()
+ .is_some_and(|d| !d.is_empty());
+
// Compute main state: combines is_main, would_conflict, integration, and divergence
let main_state = MainState::from_integration_and_counts(
data.is_main,
has_merge_tree_conflicts,
integration,
+ is_same_commit_dirty,
counts.ahead,
counts.behind,
);
@@ -521,7 +532,7 @@ impl ListItem {
// Branches don't have working trees, so pass empty diff as "inherently clean"
let empty_diff = LineDiff::default();
- let integration = determine_integration_state(
+ let integration = check_integration_state(
false, // branches are never main worktree
default_branch,
self.is_ancestor,
@@ -534,10 +545,12 @@ impl ListItem {
);
// Compute main state
+ // Branches can't have is_same_commit_dirty (no working tree)
let main_state = MainState::from_integration_and_counts(
false, // not main
has_merge_tree_conflicts,
integration,
+ false, // branches have no working tree, can't be dirty
counts.ahead,
counts.behind,
);
@@ -555,11 +568,16 @@ impl ListItem {
}
}
-/// Determine integration state for a worktree or branch.
+/// Check if branch content is integrated into main (safe to delete).
+///
+/// Returns `Some(MainState)` only for truly integrated states:
+/// - `Empty` = same commit as main with clean working tree
+/// - `Integrated(...)` = content in main via different history
///
-/// Returns `Some(MainState)` if integrated (SameCommit or Integrated), `None` otherwise.
+/// Does NOT detect `SameCommit` (same commit with dirty working tree) -
+/// that's handled separately in the caller since it's not an integration state.
#[allow(clippy::too_many_arguments)]
-fn determine_integration_state(
+fn check_integration_state(
is_main: bool,
default_branch: Option<&str>,
is_ancestor: Option<bool>,
@@ -578,9 +596,9 @@ fn determine_integration_state(
// to avoid premature integration state (which would cause UI flash during progressive loading).
let is_clean = working_tree_diff.is_some_and(|d| d.is_empty());
- // Priority 1: Branch is exactly the same commit as main (ancestor with 0 behind)
+ // Priority 1: Same commit as main + clean working tree = Empty (safe to delete)
if is_ancestor == Some(true) && behind_main == Some(0) && is_clean {
- return Some(MainState::SameCommit);
+ return Some(MainState::Empty);
}
// Priority 2: Branch is ancestor of main but main has moved past (already merged)
@@ -738,11 +756,12 @@ impl serde::Serialize for WorktreeState {
/// Priority order determines which symbol is shown:
/// 1. IsMain (^) - this IS the main branch
/// 2. WouldConflict (✗) - merge-tree simulation shows conflicts
-/// 3. SameCommit (_) - branch HEAD is exactly the same commit as main
-/// 4. Integrated (⊂) - content is in main via different history
-/// 5. Diverged (↕) - both ahead and behind main
-/// 6. Ahead (↑) - has commits main doesn't have
-/// 7. Behind (↓) - missing commits from main
+/// 3. Empty (_) - same commit as main AND clean working tree (safe to delete)
+/// 4. SameCommit (–) - same commit as main with uncommitted changes
+/// 5. Integrated (⊂) - content is in main via different history
+/// 6. Diverged (↕) - both ahead and behind main
+/// 7. Ahead (↑) - has commits main doesn't have
+/// 8. Behind (↓) - missing commits from main
///
/// The `Integrated` variant carries an [`IntegrationReason`] explaining how the
/// content was integrated (ancestor, trees match, no added changes, or merge adds nothing).
@@ -755,7 +774,9 @@ pub enum MainState {
IsMain,
/// Merge-tree conflicts with main (simulated via git merge-tree)
WouldConflict,
- /// Branch HEAD is exactly the same commit as main
+ /// Branch HEAD is same commit as main AND working tree is clean (safe to delete)
+ Empty,
+ /// Branch HEAD is same commit as main but has uncommitted changes
SameCommit,
/// Content is integrated into main via different history
Integrated(IntegrationReason),
@@ -774,7 +795,8 @@ impl std::fmt::Display for MainState {
Self::None => Ok(()),
Self::IsMain => write!(f, "^"),
Self::WouldConflict => write!(f, "✗"),
- Self::SameCommit => write!(f, "_"),
+ Self::Empty => write!(f, "_"),
+ Self::SameCommit => write!(f, "–"), // en-dash U+2013
Self::Integrated(_) => write!(f, "⊂"),
Self::Diverged => write!(f, "↕"),
Self::Ahead => write!(f, "↑"),
@@ -812,6 +834,7 @@ impl MainState {
Self::None => None,
Self::IsMain => Some("is_main"),
Self::WouldConflict => Some("would_conflict"),
+ Self::Empty => Some("empty"),
Self::SameCommit => Some("same_commit"),
Self::Integrated(_) => Some("integrated"),
Self::Diverged => Some("diverged"),
@@ -820,13 +843,14 @@ impl MainState {
}
}
- /// Compute from divergence counts and integration state.
+ /// Compute from divergence counts, integration state, and same-commit-dirty flag.
///
- /// Priority: WouldConflict > integration > Diverged > Ahead > Behind
+ /// Priority: IsMain > WouldConflict > integration > SameCommit > Diverged > Ahead > Behind
pub fn from_integration_and_counts(
is_main: bool,
would_conflict: bool,
integration: Option<MainState>,
+ is_same_commit_dirty: bool,
ahead: usize,
behind: usize,
) -> Self {
@@ -836,6 +860,8 @@ impl MainState {
Self::WouldConflict
} else if let Some(state) = integration {
state
+ } else if is_same_commit_dirty {
+ Self::SameCommit
} else {
match (ahead, behind) {
(0, 0) => Self::None,
@@ -973,7 +999,7 @@ impl PositionMask {
1, // MODIFIED: ! (1 char)
1, // UNTRACKED: ? (1 char)
1, // WORKTREE_STATE: ✘⤴⤵/⚑⊟⊞ (1 char, priority: conflicts > rebase > merge > path_mismatch > prunable > locked > branch)
- 1, // MAIN_STATE: ^✗_⊂↕↑↓ (1 char, priority: is_main > would_conflict > same_commit > integrated > diverged > ahead > behind)
+ 1, // MAIN_STATE: ^✗_–⊂↕↑↓ (1 char, priority: is_main > would_conflict > empty > same_commit > integrated > diverged > ahead > behind)
1, // UPSTREAM_DIVERGENCE: |⇡⇣⇅ (1 char)
2, // USER_MARKER: single emoji or two chars (allocate 2)
],
@@ -1008,10 +1034,11 @@ impl PositionMask {
/// - /: Branch without worktree
///
/// **Main state (single position with priority):**
-/// Priority: ^ > ✗ > _ > ⊂ > ↕ > ↑ > ↓
+/// Priority: ^ > ✗ > _ > – > ⊂ > ↕ > ↑ > ↓
/// - ^: This IS the main branch
/// - ✗: Would conflict if merged to main
-/// - _: Same commit as main (removable)
+/// - _: Same commit as main, clean working tree (removable)
+/// - –: Same commit as main, uncommitted changes (NOT removable)
/// - ⊂: Content integrated (removable)
/// - ↕: Diverged from main
/// - ↑: Ahead of main
@@ -1028,7 +1055,7 @@ impl PositionMask {
#[derive(Debug, Clone, Default)]
pub struct StatusSymbols {
/// Main branch relationship state (single position, horizontal arrows)
- /// Priority: IsMain (^) > WouldConflict (✗) > SameCommit (_) > Integrated (⊂) > Diverged (↕) > Ahead (↑) > Behind (↓)
+ /// Priority: IsMain (^) > WouldConflict (✗) > Empty (_) > SameCommit (–) > Integrated (⊂) > Diverged (↕) > Ahead (↑) > Behind (↓)
pub(crate) main_state: MainState,
/// Worktree operation and location state (single position)
@@ -1322,6 +1349,7 @@ mod tests {
MainState::WouldConflict.as_json_str(),
Some("would_conflict")
);
+ assert_eq!(MainState::Empty.as_json_str(), Some("empty"));
assert_eq!(MainState::SameCommit.as_json_str(), Some("same_commit"));
assert_eq!(
MainState::Integrated(IntegrationReason::TreesMatch).as_json_str(),
@@ -1352,6 +1380,7 @@ mod tests {
assert_eq!(MainState::None.integration_reason(), None);
assert_eq!(MainState::IsMain.integration_reason(), None);
assert_eq!(MainState::WouldConflict.integration_reason(), None);
+ assert_eq!(MainState::Empty.integration_reason(), None);
assert_eq!(MainState::SameCommit.integration_reason(), None);
assert_eq!(MainState::Diverged.integration_reason(), None);
assert_eq!(MainState::Ahead.integration_reason(), None);
@@ -1380,20 +1409,27 @@ mod tests {
fn test_main_state_from_integration_and_counts() {
// IsMain takes priority
assert!(matches!(
- MainState::from_integration_and_counts(true, false, None, 5, 3),
+ MainState::from_integration_and_counts(true, false, None, false, 5, 3),
MainState::IsMain
));
// WouldConflict next
assert!(matches!(
- MainState::from_integration_and_counts(false, true, None, 5, 3),
+ MainState::from_integration_and_counts(false, true, None, false, 5, 3),
MainState::WouldConflict
));
- // SameCommit (passed as integration state)
+ // Empty (passed as integration state - same commit with clean working tree)
assert!(matches!(
- MainState::from_integration_and_counts(false, false, Some(MainState::SameCommit), 0, 0),
- MainState::SameCommit
+ MainState::from_integration_and_counts(
+ false,
+ false,
+ Some(MainState::Empty),
+ false,
+ 0,
+ 0
+ ),
+ MainState::Empty
));
// Integrated (passed as integration state)
@@ -1402,33 +1438,40 @@ mod tests {
false,
false,
Some(MainState::Integrated(IntegrationReason::Ancestor)),
+ false,
0,
5
),
MainState::Integrated(IntegrationReason::Ancestor)
));
+ // SameCommit (via is_same_commit_dirty flag, NOT integration)
+ assert!(matches!(
+ MainState::from_integration_and_counts(false, false, None, true, 0, 0),
+ MainState::SameCommit
+ ));
+
// Diverged (both ahead and behind)
assert!(matches!(
- MainState::from_integration_and_counts(false, false, None, 3, 2),
+ MainState::from_integration_and_counts(false, false, None, false, 3, 2),
MainState::Diverged
));
// Ahead only
assert!(matches!(
- MainState::from_integration_and_counts(false, false, None, 3, 0),
+ MainState::from_integration_and_counts(false, false, None, false, 3, 0),
MainState::Ahead
));
// Behind only
assert!(matches!(
- MainState::from_integration_and_counts(false, false, None, 0, 2),
+ MainState::from_integration_and_counts(false, false, None, false, 0, 2),
MainState::Behind
));
// None (in sync)
assert!(matches!(
- MainState::from_integration_and_counts(false, false, None, 0, 0),
+ MainState::from_integration_and_counts(false, false, None, false, 0, 0),
MainState::None
));
}
diff --git a/src/git/mod.rs b/src/git/mod.rs
index 86145a20a..81688bfcf 100644
--- a/src/git/mod.rs
+++ b/src/git/mod.rs
@@ -47,8 +47,9 @@ pub use repository::{Repository, ResolvedWorktree, set_base_path};
///
/// Used by both `wt list` (for status symbols) and `wt remove` (for messages).
/// Each variant corresponds to a specific integration check. In `wt list`,
-/// two symbols represent these checks:
-/// - `_` for [`SameCommit`](Self::SameCommit) (identical commit)
+/// three symbols represent these checks:
+/// - `_` for [`SameCommit`](Self::SameCommit) with clean working tree (empty)
+/// - `–` for [`SameCommit`](Self::SameCommit) with dirty working tree
/// - `⊂` for all others (content integrated via different history)
///
/// The checks are ordered by cost (cheapest first):
@@ -64,7 +65,8 @@ pub enum IntegrationReason {
/// Branch HEAD is literally the same commit as target.
///
/// Used by `wt remove` to determine if branch is safely deletable.
- /// In `wt list`, same-commit state is shown via `MainState::SameCommit` (symbol `_`).
+ /// In `wt list`, same-commit state is shown via `MainState::Empty` (`_`) or
+ /// `MainState::SameCommit` (`–`) depending on working tree cleanliness.
SameCommit,
/// Branch HEAD is an ancestor of target (target has moved past this branch).
diff --git a/tests/snapshots/integration__integration_tests__help__help_list_long.snap b/tests/snapshots/integration__integration_tests__help__help_list_long.snap
index de16a4dd5..06a22a072 100644
--- a/tests/snapshots/integration__integration_tests__help__help_list_long.snap
+++ b/tests/snapshots/integration__integration_tests__help__help_list_long.snap
@@ -119,31 +119,32 @@ seconds; use wt config state to view or clear.
The Status column has multiple subcolumns. Within each, only the first matching symbol is shown (listed in priority order):
- Subcolumn Symbol Meaning
- ──────────────── ────── ────────────────────────────────
- Working tree (1) + Staged files
- Working tree (2) ! Modified files (unstaged)
- Working tree (3) ? Untracked files
- Worktree ✘ Merge conflicts
- ⤴ Rebase in progress
- ⤵ Merge in progress
- / Branch without worktree
- ⚑ Path doesn't match template
- ⊟ Prunable (directory missing)
- ⊞ Locked worktree
- Main ^ Is the main branch
- ✗ Would conflict if merged to main
- _ Same commit as main
- ⊂ Content integrated
- ↕ Diverged from main
- ↑ Ahead of main
- ↓ Behind main
- Remote | In sync with remote
- ⇅ Diverged from remote
- ⇡ Ahead of remote
- ⇣ Behind remote
-
-Rows are dimmed when the branch content is already in main (_ same commit or ⊂ content integrated).
+ Subcolumn Symbol Meaning
+ ──────────────── ────── ────────────────────────────────────────
+ Working tree (1) + Staged files
+ Working tree (2) ! Modified files (unstaged)
+ Working tree (3) ? Untracked files
+ Worktree ✘ Merge conflicts
+ ⤴ Rebase in progress
+ ⤵ Merge in progress
+ / Branch without worktree
+ ⚑ Path doesn't match template
+ ⊟ Prunable (directory missing)
+ ⊞ Locked worktree
+ Main ^ Is the main branch
+ ✗ Would conflict if merged to main
+ _ Same commit as main, clean
+ – Same commit as main, uncommitted changes
+ ⊂ Content integrated
+ ↕ Diverged from main
+ ↑ Ahead of main
+ ↓ Behind main
+ Remote | In sync with remote
+ ⇅ Diverged from remote
+ ⇡ Ahead of remote
+ ⇣ Behind remote
+
+Rows are dimmed when safe to delete (_ same commit with clean working tree or ⊂ content integrated).
JSON output
@@ -162,7 +163,7 @@ Query structured data with --format=json:
wt list --format=json | jq '.[] | select(.main.ahead > 0)'

# Integrated branches (ready to clean up)
- wt list --format=json | jq '.[] | select(.main_state == "integrated" or .main_state == "same_commit")'
+ wt list --format=json | jq '.[] | select(.main_state == "integrated" or .main_state == "empty")'
Fields:
@@ -173,7 +174,7 @@ Query structured data with --format=json:
kind "worktree" or "branch"
commit {sha, short_sha, message, timestamp}
working_tree {staged, modified, untracked, renamed, deleted, diff, diff_vs_main}
- main_state "is_main" "would_conflict" "same_commit" "integrated" "diverged" "ahead" "behind"
+ main_state "is_main" "would_conflict" "empty" "same_commit" "integrated" "diverged" "ahead" "behind"
integration_reason "ancestor" "trees_match" "no_added_changes" "merge_adds_nothing" (when main_state == "integrated")
operation_state "conflicts" "rebase" "merge" (absent when no operation in progress)
main {ahead, behind, diff} (absent when is_main)
diff --git a/tests/snapshots/integration__integration_tests__list__json_with_git_operation.snap b/tests/snapshots/integration__integration_tests__list__json_with_git_operation.snap
index 252906477..b5a8a4800 100644
--- a/tests/snapshots/integration__integration_tests__list__json_with_git_operation.snap
+++ b/tests/snapshots/integration__integration_tests__list__json_with_git_operation.snap
@@ -87,7 +87,7 @@ exit_code: 0
"deleted": 0
}
},
- "main_state": "same_commit",
+ "main_state": "empty",
"operation_state": "conflicts",
"main": {
"ahead": 0,
diff --git a/tests/snapshots/integration__integration_tests__list__json_with_metadata.snap b/tests/snapshots/integration__integration_tests__list__json_with_metadata.snap
index f10398f91..12e8ac1fe 100644
--- a/tests/snapshots/integration__integration_tests__list__json_with_metadata.snap
+++ b/tests/snapshots/integration__integration_tests__list__json_with_metadata.snap
@@ -87,7 +87,7 @@ exit_code: 0
"deleted": 0
}
},
- "main_state": "same_commit",
+ "main_state": "empty",
"main": {
"ahead": 0,
"behind": 0
@@ -125,7 +125,7 @@ exit_code: 0
"deleted": 0
}
},
- "main_state": "same_commit",
+ "main_state": "empty",
"main": {
"ahead": 0,
"behind": 0
diff --git a/tests/snapshots/integration__integration_tests__list__json_with_user_marker.snap b/tests/snapshots/integration__integration_tests__list__json_with_user_marker.snap
index 34a4618a7..622167b47 100644
--- a/tests/snapshots/integration__integration_tests__list__json_with_user_marker.snap
+++ b/tests/snapshots/integration__integration_tests__list__json_with_user_marker.snap
@@ -87,7 +87,7 @@ exit_code: 0
"deleted": 0
}
},
- "main_state": "same_commit",
+ "main_state": "empty",
"main": {
"ahead": 0,
"behind": 0
@@ -125,7 +125,7 @@ exit_code: 0
"deleted": 0
}
},
- "main_state": "same_commit",
+ "main_state": "empty",
"main": {
"ahead": 0,
"behind": 0
diff --git a/tests/snapshots/integration__integration_tests__list__maximum_status_with_git_operation.snap b/tests/snapshots/integration__integration_tests__list__maximum_status_with_git_operation.snap
index 3bb2c71f8..dd1c83e7b 100644
--- a/tests/snapshots/integration__integration_tests__list__maximum_status_with_git_operation.snap
+++ b/tests/snapshots/integration__integration_tests__list__maximum_status_with_git_operation.snap
@@ -30,6 +30,6 @@ exit_code: 0
----- stderr -----
Branch Status HEAD± main↕ main…± Path Remote⇅ CI Commit Age Message
@ main ^ ./repo 1c3b3fec 1d Main conflicting changes
-+ feature +!?✘ 🤖 +7 ./repo.feature 1c3b3fec 1d Main conflicting changes
++ feature +!?✘– 🤖 +7 ./repo.feature 1c3b3fec 1d Main conflicting changes
⚪ Showing 2 worktrees, 1 with changes
diff --git a/tests/snapshots/integration__integration_tests__spacing_edge_cases__alignment_empty_diffs.snap b/tests/snapshots/integration__integration_tests__spacing_edge_cases__alignment_empty_diffs.snap
index 85c260d4f..57de7e04b 100644
--- a/tests/snapshots/integration__integration_tests__spacing_edge_cases__alignment_empty_diffs.snap
+++ b/tests/snapshots/integration__integration_tests__spacing_edge_cases__alignment_empty_diffs.snap
@@ -31,6 +31,6 @@ exit_code: 0
@ main ^ ./repo a1e809f5 1d Initial commit
+ also-no-changes _ ./repo.also-no-changes a1e809f5 1d Initial commit
+ no-changes _ ./repo.no-changes a1e809f5 1d Initial commit
-+ with-changes ! +1 -1 ./repo.with-changes a1e809f5 1d Initial commit
++ with-changes ! – +1 -1 ./repo.with-changes a1e809f5 1d Initial commit
⚪ Showing 4 worktrees, 1 with changes
diff --git a/tests/snapshots/integration__integration_tests__spacing_edge_cases__alignment_extreme_diffs.snap b/tests/snapshots/integration__integration_tests__spacing_edge_cases__alignment_extreme_diffs.snap
index 559bd87de..a9684c4d3 100644
--- a/tests/snapshots/integration__integration_tests__spacing_edge_cases__alignment_extreme_diffs.snap
+++ b/tests/snapshots/integration__integration_tests__spacing_edge_cases__alignment_extreme_diffs.snap
@@ -30,6 +30,6 @@ exit_code: 0
Branch Status HEAD± main↕ Path Remote⇅ Commit Age Message
@ main ^ ./repo a1e809f5 1d Initial commit
+ huge ? _ ./repo.huge a1e809f5 1d Initial commit
-+ tiny ! +1 -1 ./repo.tiny a1e809f5 1d Initial commit
++ tiny ! – +1 -1 ./repo.tiny a1e809f5 1d Initial commit
⚪ Showing 3 worktrees, 1 with changes